//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS Pinpoint service.
///
/// Doc Engage API - Amazon Pinpoint API
public struct Pinpoint: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the Pinpoint client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            serviceName: "Pinpoint",
            serviceIdentifier: "pinpoint",
            signingName: "mobiletargeting",
            serviceProtocol: .restjson,
            apiVersion: "2016-12-01",
            endpoint: endpoint,
            serviceEndpoints: Self.serviceEndpoints,
            variantEndpoints: Self.variantEndpoints,
            errorType: PinpointErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }


    /// custom endpoints for regions
    static var serviceEndpoints: [String: String] {[
        "ca-central-1": "pinpoint.ca-central-1.amazonaws.com",
        "us-east-1": "pinpoint.us-east-1.amazonaws.com",
        "us-east-2": "pinpoint.us-east-2.amazonaws.com",
        "us-gov-west-1": "pinpoint.us-gov-west-1.amazonaws.com",
        "us-west-2": "pinpoint.us-west-2.amazonaws.com"
    ]}


    /// FIPS and dualstack endpoints
    static var variantEndpoints: [EndpointVariantType: AWSServiceConfig.EndpointVariant] {[
        [.fips]: .init(endpoints: [
            "ca-central-1": "pinpoint-fips.ca-central-1.amazonaws.com",
            "us-east-1": "pinpoint-fips.us-east-1.amazonaws.com",
            "us-east-2": "pinpoint-fips.us-east-2.amazonaws.com",
            "us-gov-west-1": "pinpoint-fips.us-gov-west-1.amazonaws.com",
            "us-west-2": "pinpoint-fips.us-west-2.amazonaws.com"
        ])
    ]}

    // MARK: API Calls

    /// Creates an application.
    @Sendable
    @inlinable
    public func createApp(_ input: CreateAppRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateAppResponse {
        try await self.client.execute(
            operation: "CreateApp", 
            path: "/v1/apps", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an application.
    ///
    /// Parameters:
    ///   - createApplicationRequest: 
    ///   - logger: Logger use during operation
    @inlinable
    public func createApp(
        createApplicationRequest: CreateApplicationRequest? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateAppResponse {
        let input = CreateAppRequest(
            createApplicationRequest: createApplicationRequest
        )
        return try await self.createApp(input, logger: logger)
    }

    /// Creates a new campaign for an application or updates the settings of an existing campaign for an application.
    @Sendable
    @inlinable
    public func createCampaign(_ input: CreateCampaignRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateCampaignResponse {
        try await self.client.execute(
            operation: "CreateCampaign", 
            path: "/v1/apps/{ApplicationId}/campaigns", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new campaign for an application or updates the settings of an existing campaign for an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - writeCampaignRequest: 
    ///   - logger: Logger use during operation
    @inlinable
    public func createCampaign(
        applicationId: String,
        writeCampaignRequest: WriteCampaignRequest? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateCampaignResponse {
        let input = CreateCampaignRequest(
            applicationId: applicationId, 
            writeCampaignRequest: writeCampaignRequest
        )
        return try await self.createCampaign(input, logger: logger)
    }

    /// Creates a message template for messages that are sent through the email channel.
    @Sendable
    @inlinable
    public func createEmailTemplate(_ input: CreateEmailTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateEmailTemplateResponse {
        try await self.client.execute(
            operation: "CreateEmailTemplate", 
            path: "/v1/templates/{TemplateName}/email", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a message template for messages that are sent through the email channel.
    ///
    /// Parameters:
    ///   - emailTemplateRequest: 
    ///   - templateName: The name of the message template. A template name must start with an alphanumeric character and can contain a maximum of 128 characters. The characters can be alphanumeric characters, underscores (_), or hyphens (-). Template names are case sensitive.
    ///   - logger: Logger use during operation
    @inlinable
    public func createEmailTemplate(
        emailTemplateRequest: EmailTemplateRequest? = nil,
        templateName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateEmailTemplateResponse {
        let input = CreateEmailTemplateRequest(
            emailTemplateRequest: emailTemplateRequest, 
            templateName: templateName
        )
        return try await self.createEmailTemplate(input, logger: logger)
    }

    /// Creates an export job for an application.
    @Sendable
    @inlinable
    public func createExportJob(_ input: CreateExportJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateExportJobResponse {
        try await self.client.execute(
            operation: "CreateExportJob", 
            path: "/v1/apps/{ApplicationId}/jobs/export", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an export job for an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - exportJobRequest: 
    ///   - logger: Logger use during operation
    @inlinable
    public func createExportJob(
        applicationId: String,
        exportJobRequest: ExportJobRequest? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateExportJobResponse {
        let input = CreateExportJobRequest(
            applicationId: applicationId, 
            exportJobRequest: exportJobRequest
        )
        return try await self.createExportJob(input, logger: logger)
    }

    /// Creates an import job for an application.
    @Sendable
    @inlinable
    public func createImportJob(_ input: CreateImportJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateImportJobResponse {
        try await self.client.execute(
            operation: "CreateImportJob", 
            path: "/v1/apps/{ApplicationId}/jobs/import", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an import job for an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - importJobRequest: 
    ///   - logger: Logger use during operation
    @inlinable
    public func createImportJob(
        applicationId: String,
        importJobRequest: ImportJobRequest? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateImportJobResponse {
        let input = CreateImportJobRequest(
            applicationId: applicationId, 
            importJobRequest: importJobRequest
        )
        return try await self.createImportJob(input, logger: logger)
    }

    /// Creates a new message template for messages using the in-app message channel.
    @Sendable
    @inlinable
    public func createInAppTemplate(_ input: CreateInAppTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateInAppTemplateResponse {
        try await self.client.execute(
            operation: "CreateInAppTemplate", 
            path: "/v1/templates/{TemplateName}/inapp", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new message template for messages using the in-app message channel.
    ///
    /// Parameters:
    ///   - inAppTemplateRequest: 
    ///   - templateName: The name of the message template. A template name must start with an alphanumeric character and can contain a maximum of 128 characters. The characters can be alphanumeric characters, underscores (_), or hyphens (-). Template names are case sensitive.
    ///   - logger: Logger use during operation
    @inlinable
    public func createInAppTemplate(
        inAppTemplateRequest: InAppTemplateRequest? = nil,
        templateName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateInAppTemplateResponse {
        let input = CreateInAppTemplateRequest(
            inAppTemplateRequest: inAppTemplateRequest, 
            templateName: templateName
        )
        return try await self.createInAppTemplate(input, logger: logger)
    }

    /// Creates a journey for an application.
    @Sendable
    @inlinable
    public func createJourney(_ input: CreateJourneyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateJourneyResponse {
        try await self.client.execute(
            operation: "CreateJourney", 
            path: "/v1/apps/{ApplicationId}/journeys", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a journey for an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - writeJourneyRequest: 
    ///   - logger: Logger use during operation
    @inlinable
    public func createJourney(
        applicationId: String,
        writeJourneyRequest: WriteJourneyRequest? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateJourneyResponse {
        let input = CreateJourneyRequest(
            applicationId: applicationId, 
            writeJourneyRequest: writeJourneyRequest
        )
        return try await self.createJourney(input, logger: logger)
    }

    /// Creates a message template for messages that are sent through a push notification channel.
    @Sendable
    @inlinable
    public func createPushTemplate(_ input: CreatePushTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreatePushTemplateResponse {
        try await self.client.execute(
            operation: "CreatePushTemplate", 
            path: "/v1/templates/{TemplateName}/push", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a message template for messages that are sent through a push notification channel.
    ///
    /// Parameters:
    ///   - pushNotificationTemplateRequest: 
    ///   - templateName: The name of the message template. A template name must start with an alphanumeric character and can contain a maximum of 128 characters. The characters can be alphanumeric characters, underscores (_), or hyphens (-). Template names are case sensitive.
    ///   - logger: Logger use during operation
    @inlinable
    public func createPushTemplate(
        pushNotificationTemplateRequest: PushNotificationTemplateRequest? = nil,
        templateName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreatePushTemplateResponse {
        let input = CreatePushTemplateRequest(
            pushNotificationTemplateRequest: pushNotificationTemplateRequest, 
            templateName: templateName
        )
        return try await self.createPushTemplate(input, logger: logger)
    }

    /// Creates an Amazon Pinpoint configuration for a recommender model.
    @Sendable
    @inlinable
    public func createRecommenderConfiguration(_ input: CreateRecommenderConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateRecommenderConfigurationResponse {
        try await self.client.execute(
            operation: "CreateRecommenderConfiguration", 
            path: "/v1/recommenders", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an Amazon Pinpoint configuration for a recommender model.
    ///
    /// Parameters:
    ///   - createRecommenderConfiguration: 
    ///   - logger: Logger use during operation
    @inlinable
    public func createRecommenderConfiguration(
        createRecommenderConfiguration: CreateRecommenderConfigurationShape? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateRecommenderConfigurationResponse {
        let input = CreateRecommenderConfigurationRequest(
            createRecommenderConfiguration: createRecommenderConfiguration
        )
        return try await self.createRecommenderConfiguration(input, logger: logger)
    }

    /// Creates a new segment for an application or updates the configuration, dimension, and other settings for an existing segment that's associated with an application.
    @Sendable
    @inlinable
    public func createSegment(_ input: CreateSegmentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateSegmentResponse {
        try await self.client.execute(
            operation: "CreateSegment", 
            path: "/v1/apps/{ApplicationId}/segments", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new segment for an application or updates the configuration, dimension, and other settings for an existing segment that's associated with an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - writeSegmentRequest: 
    ///   - logger: Logger use during operation
    @inlinable
    public func createSegment(
        applicationId: String,
        writeSegmentRequest: WriteSegmentRequest? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateSegmentResponse {
        let input = CreateSegmentRequest(
            applicationId: applicationId, 
            writeSegmentRequest: writeSegmentRequest
        )
        return try await self.createSegment(input, logger: logger)
    }

    /// Creates a message template for messages that are sent through the SMS channel.
    @Sendable
    @inlinable
    public func createSmsTemplate(_ input: CreateSmsTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateSmsTemplateResponse {
        try await self.client.execute(
            operation: "CreateSmsTemplate", 
            path: "/v1/templates/{TemplateName}/sms", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a message template for messages that are sent through the SMS channel.
    ///
    /// Parameters:
    ///   - smsTemplateRequest: 
    ///   - templateName: The name of the message template. A template name must start with an alphanumeric character and can contain a maximum of 128 characters. The characters can be alphanumeric characters, underscores (_), or hyphens (-). Template names are case sensitive.
    ///   - logger: Logger use during operation
    @inlinable
    public func createSmsTemplate(
        smsTemplateRequest: SMSTemplateRequest? = nil,
        templateName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateSmsTemplateResponse {
        let input = CreateSmsTemplateRequest(
            smsTemplateRequest: smsTemplateRequest, 
            templateName: templateName
        )
        return try await self.createSmsTemplate(input, logger: logger)
    }

    /// Creates a message template for messages that are sent through the voice channel.
    @Sendable
    @inlinable
    public func createVoiceTemplate(_ input: CreateVoiceTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateVoiceTemplateResponse {
        try await self.client.execute(
            operation: "CreateVoiceTemplate", 
            path: "/v1/templates/{TemplateName}/voice", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a message template for messages that are sent through the voice channel.
    ///
    /// Parameters:
    ///   - templateName: The name of the message template. A template name must start with an alphanumeric character and can contain a maximum of 128 characters. The characters can be alphanumeric characters, underscores (_), or hyphens (-). Template names are case sensitive.
    ///   - voiceTemplateRequest: 
    ///   - logger: Logger use during operation
    @inlinable
    public func createVoiceTemplate(
        templateName: String,
        voiceTemplateRequest: VoiceTemplateRequest? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateVoiceTemplateResponse {
        let input = CreateVoiceTemplateRequest(
            templateName: templateName, 
            voiceTemplateRequest: voiceTemplateRequest
        )
        return try await self.createVoiceTemplate(input, logger: logger)
    }

    /// Disables the ADM channel for an application and deletes any existing settings for the channel.
    @Sendable
    @inlinable
    public func deleteAdmChannel(_ input: DeleteAdmChannelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteAdmChannelResponse {
        try await self.client.execute(
            operation: "DeleteAdmChannel", 
            path: "/v1/apps/{ApplicationId}/channels/adm", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disables the ADM channel for an application and deletes any existing settings for the channel.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteAdmChannel(
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteAdmChannelResponse {
        let input = DeleteAdmChannelRequest(
            applicationId: applicationId
        )
        return try await self.deleteAdmChannel(input, logger: logger)
    }

    /// Disables the APNs channel for an application and deletes any existing settings for the channel.
    @Sendable
    @inlinable
    public func deleteApnsChannel(_ input: DeleteApnsChannelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteApnsChannelResponse {
        try await self.client.execute(
            operation: "DeleteApnsChannel", 
            path: "/v1/apps/{ApplicationId}/channels/apns", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disables the APNs channel for an application and deletes any existing settings for the channel.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteApnsChannel(
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteApnsChannelResponse {
        let input = DeleteApnsChannelRequest(
            applicationId: applicationId
        )
        return try await self.deleteApnsChannel(input, logger: logger)
    }

    /// Disables the APNs sandbox channel for an application and deletes any existing settings for the channel.
    @Sendable
    @inlinable
    public func deleteApnsSandboxChannel(_ input: DeleteApnsSandboxChannelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteApnsSandboxChannelResponse {
        try await self.client.execute(
            operation: "DeleteApnsSandboxChannel", 
            path: "/v1/apps/{ApplicationId}/channels/apns_sandbox", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disables the APNs sandbox channel for an application and deletes any existing settings for the channel.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteApnsSandboxChannel(
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteApnsSandboxChannelResponse {
        let input = DeleteApnsSandboxChannelRequest(
            applicationId: applicationId
        )
        return try await self.deleteApnsSandboxChannel(input, logger: logger)
    }

    /// Disables the APNs VoIP channel for an application and deletes any existing settings for the channel.
    @Sendable
    @inlinable
    public func deleteApnsVoipChannel(_ input: DeleteApnsVoipChannelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteApnsVoipChannelResponse {
        try await self.client.execute(
            operation: "DeleteApnsVoipChannel", 
            path: "/v1/apps/{ApplicationId}/channels/apns_voip", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disables the APNs VoIP channel for an application and deletes any existing settings for the channel.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteApnsVoipChannel(
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteApnsVoipChannelResponse {
        let input = DeleteApnsVoipChannelRequest(
            applicationId: applicationId
        )
        return try await self.deleteApnsVoipChannel(input, logger: logger)
    }

    /// Disables the APNs VoIP sandbox channel for an application and deletes any existing settings for the channel.
    @Sendable
    @inlinable
    public func deleteApnsVoipSandboxChannel(_ input: DeleteApnsVoipSandboxChannelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteApnsVoipSandboxChannelResponse {
        try await self.client.execute(
            operation: "DeleteApnsVoipSandboxChannel", 
            path: "/v1/apps/{ApplicationId}/channels/apns_voip_sandbox", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disables the APNs VoIP sandbox channel for an application and deletes any existing settings for the channel.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteApnsVoipSandboxChannel(
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteApnsVoipSandboxChannelResponse {
        let input = DeleteApnsVoipSandboxChannelRequest(
            applicationId: applicationId
        )
        return try await self.deleteApnsVoipSandboxChannel(input, logger: logger)
    }

    /// Deletes an application.
    @Sendable
    @inlinable
    public func deleteApp(_ input: DeleteAppRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteAppResponse {
        try await self.client.execute(
            operation: "DeleteApp", 
            path: "/v1/apps/{ApplicationId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteApp(
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteAppResponse {
        let input = DeleteAppRequest(
            applicationId: applicationId
        )
        return try await self.deleteApp(input, logger: logger)
    }

    /// Disables the Baidu channel for an application and deletes any existing settings for the channel.
    @Sendable
    @inlinable
    public func deleteBaiduChannel(_ input: DeleteBaiduChannelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteBaiduChannelResponse {
        try await self.client.execute(
            operation: "DeleteBaiduChannel", 
            path: "/v1/apps/{ApplicationId}/channels/baidu", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disables the Baidu channel for an application and deletes any existing settings for the channel.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteBaiduChannel(
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteBaiduChannelResponse {
        let input = DeleteBaiduChannelRequest(
            applicationId: applicationId
        )
        return try await self.deleteBaiduChannel(input, logger: logger)
    }

    /// Deletes a campaign from an application.
    @Sendable
    @inlinable
    public func deleteCampaign(_ input: DeleteCampaignRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteCampaignResponse {
        try await self.client.execute(
            operation: "DeleteCampaign", 
            path: "/v1/apps/{ApplicationId}/campaigns/{CampaignId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a campaign from an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - campaignId: The unique identifier for the campaign.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteCampaign(
        applicationId: String,
        campaignId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteCampaignResponse {
        let input = DeleteCampaignRequest(
            applicationId: applicationId, 
            campaignId: campaignId
        )
        return try await self.deleteCampaign(input, logger: logger)
    }

    /// Disables the email channel for an application and deletes any existing settings for the channel.
    @Sendable
    @inlinable
    public func deleteEmailChannel(_ input: DeleteEmailChannelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteEmailChannelResponse {
        try await self.client.execute(
            operation: "DeleteEmailChannel", 
            path: "/v1/apps/{ApplicationId}/channels/email", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disables the email channel for an application and deletes any existing settings for the channel.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteEmailChannel(
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteEmailChannelResponse {
        let input = DeleteEmailChannelRequest(
            applicationId: applicationId
        )
        return try await self.deleteEmailChannel(input, logger: logger)
    }

    /// Deletes a message template for messages that were sent through the email channel.
    @Sendable
    @inlinable
    public func deleteEmailTemplate(_ input: DeleteEmailTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteEmailTemplateResponse {
        try await self.client.execute(
            operation: "DeleteEmailTemplate", 
            path: "/v1/templates/{TemplateName}/email", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a message template for messages that were sent through the email channel.
    ///
    /// Parameters:
    ///   - templateName: The name of the message template. A template name must start with an alphanumeric character and can contain a maximum of 128 characters. The characters can be alphanumeric characters, underscores (_), or hyphens (-). Template names are case sensitive.
    ///   - version: The unique identifier for the version of the message template to update, retrieve information about, or delete. To retrieve identifiers and other information for all the versions of a template, use the Template Versions resource. If specified, this value must match the identifier for an existing template version. If specified for an update operation, this value must match the identifier for the latest existing version of the template. This restriction helps ensure that race conditions don't occur. If you don't specify a value for this parameter, Amazon Pinpoint does the following: For a get operation, retrieves information about the active version of the template. For an update operation, saves the updates to (overwrites) the latest existing version of the template, if the create-new-version parameter isn't used or is set to false. For a delete operation, deletes the template, including all versions of the template.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteEmailTemplate(
        templateName: String,
        version: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteEmailTemplateResponse {
        let input = DeleteEmailTemplateRequest(
            templateName: templateName, 
            version: version
        )
        return try await self.deleteEmailTemplate(input, logger: logger)
    }

    /// Deletes an endpoint from an application.
    @Sendable
    @inlinable
    public func deleteEndpoint(_ input: DeleteEndpointRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteEndpointResponse {
        try await self.client.execute(
            operation: "DeleteEndpoint", 
            path: "/v1/apps/{ApplicationId}/endpoints/{EndpointId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an endpoint from an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - endpointId: The case insensitive unique identifier for the endpoint. The identifier can't contain $, { or }.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteEndpoint(
        applicationId: String,
        endpointId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteEndpointResponse {
        let input = DeleteEndpointRequest(
            applicationId: applicationId, 
            endpointId: endpointId
        )
        return try await self.deleteEndpoint(input, logger: logger)
    }

    /// Deletes the event stream for an application.
    @Sendable
    @inlinable
    public func deleteEventStream(_ input: DeleteEventStreamRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteEventStreamResponse {
        try await self.client.execute(
            operation: "DeleteEventStream", 
            path: "/v1/apps/{ApplicationId}/eventstream", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the event stream for an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteEventStream(
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteEventStreamResponse {
        let input = DeleteEventStreamRequest(
            applicationId: applicationId
        )
        return try await self.deleteEventStream(input, logger: logger)
    }

    /// Disables the GCM channel for an application and deletes any existing settings for the channel.
    @Sendable
    @inlinable
    public func deleteGcmChannel(_ input: DeleteGcmChannelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteGcmChannelResponse {
        try await self.client.execute(
            operation: "DeleteGcmChannel", 
            path: "/v1/apps/{ApplicationId}/channels/gcm", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disables the GCM channel for an application and deletes any existing settings for the channel.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteGcmChannel(
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteGcmChannelResponse {
        let input = DeleteGcmChannelRequest(
            applicationId: applicationId
        )
        return try await self.deleteGcmChannel(input, logger: logger)
    }

    /// Deletes a message template for messages sent using the in-app message channel.
    @Sendable
    @inlinable
    public func deleteInAppTemplate(_ input: DeleteInAppTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteInAppTemplateResponse {
        try await self.client.execute(
            operation: "DeleteInAppTemplate", 
            path: "/v1/templates/{TemplateName}/inapp", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a message template for messages sent using the in-app message channel.
    ///
    /// Parameters:
    ///   - templateName: The name of the message template. A template name must start with an alphanumeric character and can contain a maximum of 128 characters. The characters can be alphanumeric characters, underscores (_), or hyphens (-). Template names are case sensitive.
    ///   - version: The unique identifier for the version of the message template to update, retrieve information about, or delete. To retrieve identifiers and other information for all the versions of a template, use the Template Versions resource. If specified, this value must match the identifier for an existing template version. If specified for an update operation, this value must match the identifier for the latest existing version of the template. This restriction helps ensure that race conditions don't occur. If you don't specify a value for this parameter, Amazon Pinpoint does the following: For a get operation, retrieves information about the active version of the template. For an update operation, saves the updates to (overwrites) the latest existing version of the template, if the create-new-version parameter isn't used or is set to false. For a delete operation, deletes the template, including all versions of the template.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteInAppTemplate(
        templateName: String,
        version: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteInAppTemplateResponse {
        let input = DeleteInAppTemplateRequest(
            templateName: templateName, 
            version: version
        )
        return try await self.deleteInAppTemplate(input, logger: logger)
    }

    /// Deletes a journey from an application.
    @Sendable
    @inlinable
    public func deleteJourney(_ input: DeleteJourneyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteJourneyResponse {
        try await self.client.execute(
            operation: "DeleteJourney", 
            path: "/v1/apps/{ApplicationId}/journeys/{JourneyId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a journey from an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - journeyId: The unique identifier for the journey.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteJourney(
        applicationId: String,
        journeyId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteJourneyResponse {
        let input = DeleteJourneyRequest(
            applicationId: applicationId, 
            journeyId: journeyId
        )
        return try await self.deleteJourney(input, logger: logger)
    }

    /// Deletes a message template for messages that were sent through a push notification channel.
    @Sendable
    @inlinable
    public func deletePushTemplate(_ input: DeletePushTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeletePushTemplateResponse {
        try await self.client.execute(
            operation: "DeletePushTemplate", 
            path: "/v1/templates/{TemplateName}/push", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a message template for messages that were sent through a push notification channel.
    ///
    /// Parameters:
    ///   - templateName: The name of the message template. A template name must start with an alphanumeric character and can contain a maximum of 128 characters. The characters can be alphanumeric characters, underscores (_), or hyphens (-). Template names are case sensitive.
    ///   - version: The unique identifier for the version of the message template to update, retrieve information about, or delete. To retrieve identifiers and other information for all the versions of a template, use the Template Versions resource. If specified, this value must match the identifier for an existing template version. If specified for an update operation, this value must match the identifier for the latest existing version of the template. This restriction helps ensure that race conditions don't occur. If you don't specify a value for this parameter, Amazon Pinpoint does the following: For a get operation, retrieves information about the active version of the template. For an update operation, saves the updates to (overwrites) the latest existing version of the template, if the create-new-version parameter isn't used or is set to false. For a delete operation, deletes the template, including all versions of the template.
    ///   - logger: Logger use during operation
    @inlinable
    public func deletePushTemplate(
        templateName: String,
        version: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeletePushTemplateResponse {
        let input = DeletePushTemplateRequest(
            templateName: templateName, 
            version: version
        )
        return try await self.deletePushTemplate(input, logger: logger)
    }

    /// Deletes an Amazon Pinpoint configuration for a recommender model.
    @Sendable
    @inlinable
    public func deleteRecommenderConfiguration(_ input: DeleteRecommenderConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteRecommenderConfigurationResponse {
        try await self.client.execute(
            operation: "DeleteRecommenderConfiguration", 
            path: "/v1/recommenders/{RecommenderId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an Amazon Pinpoint configuration for a recommender model.
    ///
    /// Parameters:
    ///   - recommenderId: The unique identifier for the recommender model configuration. This identifier is displayed as the Recommender ID on the Amazon Pinpoint console.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteRecommenderConfiguration(
        recommenderId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteRecommenderConfigurationResponse {
        let input = DeleteRecommenderConfigurationRequest(
            recommenderId: recommenderId
        )
        return try await self.deleteRecommenderConfiguration(input, logger: logger)
    }

    /// Deletes a segment from an application.
    @Sendable
    @inlinable
    public func deleteSegment(_ input: DeleteSegmentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteSegmentResponse {
        try await self.client.execute(
            operation: "DeleteSegment", 
            path: "/v1/apps/{ApplicationId}/segments/{SegmentId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a segment from an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - segmentId: The unique identifier for the segment.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteSegment(
        applicationId: String,
        segmentId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteSegmentResponse {
        let input = DeleteSegmentRequest(
            applicationId: applicationId, 
            segmentId: segmentId
        )
        return try await self.deleteSegment(input, logger: logger)
    }

    /// Disables the SMS channel for an application and deletes any existing settings for the channel.
    @Sendable
    @inlinable
    public func deleteSmsChannel(_ input: DeleteSmsChannelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteSmsChannelResponse {
        try await self.client.execute(
            operation: "DeleteSmsChannel", 
            path: "/v1/apps/{ApplicationId}/channels/sms", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disables the SMS channel for an application and deletes any existing settings for the channel.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteSmsChannel(
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteSmsChannelResponse {
        let input = DeleteSmsChannelRequest(
            applicationId: applicationId
        )
        return try await self.deleteSmsChannel(input, logger: logger)
    }

    /// Deletes a message template for messages that were sent through the SMS channel.
    @Sendable
    @inlinable
    public func deleteSmsTemplate(_ input: DeleteSmsTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteSmsTemplateResponse {
        try await self.client.execute(
            operation: "DeleteSmsTemplate", 
            path: "/v1/templates/{TemplateName}/sms", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a message template for messages that were sent through the SMS channel.
    ///
    /// Parameters:
    ///   - templateName: The name of the message template. A template name must start with an alphanumeric character and can contain a maximum of 128 characters. The characters can be alphanumeric characters, underscores (_), or hyphens (-). Template names are case sensitive.
    ///   - version: The unique identifier for the version of the message template to update, retrieve information about, or delete. To retrieve identifiers and other information for all the versions of a template, use the Template Versions resource. If specified, this value must match the identifier for an existing template version. If specified for an update operation, this value must match the identifier for the latest existing version of the template. This restriction helps ensure that race conditions don't occur. If you don't specify a value for this parameter, Amazon Pinpoint does the following: For a get operation, retrieves information about the active version of the template. For an update operation, saves the updates to (overwrites) the latest existing version of the template, if the create-new-version parameter isn't used or is set to false. For a delete operation, deletes the template, including all versions of the template.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteSmsTemplate(
        templateName: String,
        version: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteSmsTemplateResponse {
        let input = DeleteSmsTemplateRequest(
            templateName: templateName, 
            version: version
        )
        return try await self.deleteSmsTemplate(input, logger: logger)
    }

    /// Deletes all the endpoints that are associated with a specific user ID.
    @Sendable
    @inlinable
    public func deleteUserEndpoints(_ input: DeleteUserEndpointsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteUserEndpointsResponse {
        try await self.client.execute(
            operation: "DeleteUserEndpoints", 
            path: "/v1/apps/{ApplicationId}/users/{UserId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes all the endpoints that are associated with a specific user ID.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - userId: The unique identifier for the user.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteUserEndpoints(
        applicationId: String,
        userId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteUserEndpointsResponse {
        let input = DeleteUserEndpointsRequest(
            applicationId: applicationId, 
            userId: userId
        )
        return try await self.deleteUserEndpoints(input, logger: logger)
    }

    /// Disables the voice channel for an application and deletes any existing settings for the channel.
    @Sendable
    @inlinable
    public func deleteVoiceChannel(_ input: DeleteVoiceChannelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteVoiceChannelResponse {
        try await self.client.execute(
            operation: "DeleteVoiceChannel", 
            path: "/v1/apps/{ApplicationId}/channels/voice", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disables the voice channel for an application and deletes any existing settings for the channel.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteVoiceChannel(
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteVoiceChannelResponse {
        let input = DeleteVoiceChannelRequest(
            applicationId: applicationId
        )
        return try await self.deleteVoiceChannel(input, logger: logger)
    }

    /// Deletes a message template for messages that were sent through the voice channel.
    @Sendable
    @inlinable
    public func deleteVoiceTemplate(_ input: DeleteVoiceTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteVoiceTemplateResponse {
        try await self.client.execute(
            operation: "DeleteVoiceTemplate", 
            path: "/v1/templates/{TemplateName}/voice", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a message template for messages that were sent through the voice channel.
    ///
    /// Parameters:
    ///   - templateName: The name of the message template. A template name must start with an alphanumeric character and can contain a maximum of 128 characters. The characters can be alphanumeric characters, underscores (_), or hyphens (-). Template names are case sensitive.
    ///   - version: The unique identifier for the version of the message template to update, retrieve information about, or delete. To retrieve identifiers and other information for all the versions of a template, use the Template Versions resource. If specified, this value must match the identifier for an existing template version. If specified for an update operation, this value must match the identifier for the latest existing version of the template. This restriction helps ensure that race conditions don't occur. If you don't specify a value for this parameter, Amazon Pinpoint does the following: For a get operation, retrieves information about the active version of the template. For an update operation, saves the updates to (overwrites) the latest existing version of the template, if the create-new-version parameter isn't used or is set to false. For a delete operation, deletes the template, including all versions of the template.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteVoiceTemplate(
        templateName: String,
        version: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteVoiceTemplateResponse {
        let input = DeleteVoiceTemplateRequest(
            templateName: templateName, 
            version: version
        )
        return try await self.deleteVoiceTemplate(input, logger: logger)
    }

    /// Retrieves information about the status and settings of the ADM channel for an application.
    @Sendable
    @inlinable
    public func getAdmChannel(_ input: GetAdmChannelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAdmChannelResponse {
        try await self.client.execute(
            operation: "GetAdmChannel", 
            path: "/v1/apps/{ApplicationId}/channels/adm", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the status and settings of the ADM channel for an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - logger: Logger use during operation
    @inlinable
    public func getAdmChannel(
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAdmChannelResponse {
        let input = GetAdmChannelRequest(
            applicationId: applicationId
        )
        return try await self.getAdmChannel(input, logger: logger)
    }

    /// Retrieves information about the status and settings of the APNs channel for an application.
    @Sendable
    @inlinable
    public func getApnsChannel(_ input: GetApnsChannelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetApnsChannelResponse {
        try await self.client.execute(
            operation: "GetApnsChannel", 
            path: "/v1/apps/{ApplicationId}/channels/apns", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the status and settings of the APNs channel for an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - logger: Logger use during operation
    @inlinable
    public func getApnsChannel(
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetApnsChannelResponse {
        let input = GetApnsChannelRequest(
            applicationId: applicationId
        )
        return try await self.getApnsChannel(input, logger: logger)
    }

    /// Retrieves information about the status and settings of the APNs sandbox channel for an application.
    @Sendable
    @inlinable
    public func getApnsSandboxChannel(_ input: GetApnsSandboxChannelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetApnsSandboxChannelResponse {
        try await self.client.execute(
            operation: "GetApnsSandboxChannel", 
            path: "/v1/apps/{ApplicationId}/channels/apns_sandbox", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the status and settings of the APNs sandbox channel for an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - logger: Logger use during operation
    @inlinable
    public func getApnsSandboxChannel(
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetApnsSandboxChannelResponse {
        let input = GetApnsSandboxChannelRequest(
            applicationId: applicationId
        )
        return try await self.getApnsSandboxChannel(input, logger: logger)
    }

    /// Retrieves information about the status and settings of the APNs VoIP channel for an application.
    @Sendable
    @inlinable
    public func getApnsVoipChannel(_ input: GetApnsVoipChannelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetApnsVoipChannelResponse {
        try await self.client.execute(
            operation: "GetApnsVoipChannel", 
            path: "/v1/apps/{ApplicationId}/channels/apns_voip", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the status and settings of the APNs VoIP channel for an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - logger: Logger use during operation
    @inlinable
    public func getApnsVoipChannel(
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetApnsVoipChannelResponse {
        let input = GetApnsVoipChannelRequest(
            applicationId: applicationId
        )
        return try await self.getApnsVoipChannel(input, logger: logger)
    }

    /// Retrieves information about the status and settings of the APNs VoIP sandbox channel for an application.
    @Sendable
    @inlinable
    public func getApnsVoipSandboxChannel(_ input: GetApnsVoipSandboxChannelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetApnsVoipSandboxChannelResponse {
        try await self.client.execute(
            operation: "GetApnsVoipSandboxChannel", 
            path: "/v1/apps/{ApplicationId}/channels/apns_voip_sandbox", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the status and settings of the APNs VoIP sandbox channel for an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - logger: Logger use during operation
    @inlinable
    public func getApnsVoipSandboxChannel(
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetApnsVoipSandboxChannelResponse {
        let input = GetApnsVoipSandboxChannelRequest(
            applicationId: applicationId
        )
        return try await self.getApnsVoipSandboxChannel(input, logger: logger)
    }

    /// Retrieves information about an application.
    @Sendable
    @inlinable
    public func getApp(_ input: GetAppRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAppResponse {
        try await self.client.execute(
            operation: "GetApp", 
            path: "/v1/apps/{ApplicationId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - logger: Logger use during operation
    @inlinable
    public func getApp(
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAppResponse {
        let input = GetAppRequest(
            applicationId: applicationId
        )
        return try await self.getApp(input, logger: logger)
    }

    /// Retrieves (queries) pre-aggregated data for a standard metric that applies to an application.
    @Sendable
    @inlinable
    public func getApplicationDateRangeKpi(_ input: GetApplicationDateRangeKpiRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetApplicationDateRangeKpiResponse {
        try await self.client.execute(
            operation: "GetApplicationDateRangeKpi", 
            path: "/v1/apps/{ApplicationId}/kpis/daterange/{KpiName}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves (queries) pre-aggregated data for a standard metric that applies to an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - endTime: The last date and time to retrieve data for, as part of an inclusive date range that filters the query results. This value should be in extended ISO 8601 format and use Coordinated Universal Time (UTC), for example: 2019-07-26T20:00:00Z for 8:00 PM UTC July 26, 2019.
    ///   - kpiName: The name of the metric, also referred to as a key performance indicator (KPI), to retrieve data for. This value describes the associated metric and consists of two or more terms, which are comprised of lowercase alphanumeric characters, separated by a hyphen. Examples are email-open-rate and successful-delivery-rate. For a list of valid values, see the Amazon Pinpoint Developer Guide.
    ///   - nextToken: The  string that specifies which page of results to return in a paginated response. This parameter is not supported for application, campaign, and journey metrics.
    ///   - pageSize: The maximum number of items to include in each page of a paginated response. This parameter is not supported for application, campaign, and journey metrics.
    ///   - startTime: The first date and time to retrieve data for, as part of an inclusive date range that filters the query results. This value should be in extended ISO 8601 format and use Coordinated Universal Time (UTC), for example: 2019-07-19T20:00:00Z for 8:00 PM UTC July 19, 2019. This value should also be fewer than 90 days from the current day.
    ///   - logger: Logger use during operation
    @inlinable
    public func getApplicationDateRangeKpi(
        applicationId: String,
        endTime: Date? = nil,
        kpiName: String,
        nextToken: String? = nil,
        pageSize: String? = nil,
        startTime: Date? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetApplicationDateRangeKpiResponse {
        let input = GetApplicationDateRangeKpiRequest(
            applicationId: applicationId, 
            endTime: endTime, 
            kpiName: kpiName, 
            nextToken: nextToken, 
            pageSize: pageSize, 
            startTime: startTime
        )
        return try await self.getApplicationDateRangeKpi(input, logger: logger)
    }

    /// Retrieves information about the settings for an application.
    @Sendable
    @inlinable
    public func getApplicationSettings(_ input: GetApplicationSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetApplicationSettingsResponse {
        try await self.client.execute(
            operation: "GetApplicationSettings", 
            path: "/v1/apps/{ApplicationId}/settings", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the settings for an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - logger: Logger use during operation
    @inlinable
    public func getApplicationSettings(
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetApplicationSettingsResponse {
        let input = GetApplicationSettingsRequest(
            applicationId: applicationId
        )
        return try await self.getApplicationSettings(input, logger: logger)
    }

    /// Retrieves information about all the applications that are associated with your Amazon Pinpoint account.
    @Sendable
    @inlinable
    public func getApps(_ input: GetAppsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAppsResponse {
        try await self.client.execute(
            operation: "GetApps", 
            path: "/v1/apps", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about all the applications that are associated with your Amazon Pinpoint account.
    ///
    /// Parameters:
    ///   - pageSize: The maximum number of items to include in each page of a paginated response. This parameter is not supported for application, campaign, and journey metrics.
    ///   - token: The NextToken string that specifies which page of results to return in a paginated response.
    ///   - logger: Logger use during operation
    @inlinable
    public func getApps(
        pageSize: String? = nil,
        token: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAppsResponse {
        let input = GetAppsRequest(
            pageSize: pageSize, 
            token: token
        )
        return try await self.getApps(input, logger: logger)
    }

    /// Retrieves information about the status and settings of the Baidu channel for an application.
    @Sendable
    @inlinable
    public func getBaiduChannel(_ input: GetBaiduChannelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetBaiduChannelResponse {
        try await self.client.execute(
            operation: "GetBaiduChannel", 
            path: "/v1/apps/{ApplicationId}/channels/baidu", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the status and settings of the Baidu channel for an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - logger: Logger use during operation
    @inlinable
    public func getBaiduChannel(
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetBaiduChannelResponse {
        let input = GetBaiduChannelRequest(
            applicationId: applicationId
        )
        return try await self.getBaiduChannel(input, logger: logger)
    }

    /// Retrieves information about the status, configuration, and other settings for a campaign.
    @Sendable
    @inlinable
    public func getCampaign(_ input: GetCampaignRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCampaignResponse {
        try await self.client.execute(
            operation: "GetCampaign", 
            path: "/v1/apps/{ApplicationId}/campaigns/{CampaignId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the status, configuration, and other settings for a campaign.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - campaignId: The unique identifier for the campaign.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCampaign(
        applicationId: String,
        campaignId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCampaignResponse {
        let input = GetCampaignRequest(
            applicationId: applicationId, 
            campaignId: campaignId
        )
        return try await self.getCampaign(input, logger: logger)
    }

    /// Retrieves information about all the activities for a campaign.
    @Sendable
    @inlinable
    public func getCampaignActivities(_ input: GetCampaignActivitiesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCampaignActivitiesResponse {
        try await self.client.execute(
            operation: "GetCampaignActivities", 
            path: "/v1/apps/{ApplicationId}/campaigns/{CampaignId}/activities", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about all the activities for a campaign.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - campaignId: The unique identifier for the campaign.
    ///   - pageSize: The maximum number of items to include in each page of a paginated response. This parameter is not supported for application, campaign, and journey metrics.
    ///   - token: The NextToken string that specifies which page of results to return in a paginated response.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCampaignActivities(
        applicationId: String,
        campaignId: String,
        pageSize: String? = nil,
        token: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCampaignActivitiesResponse {
        let input = GetCampaignActivitiesRequest(
            applicationId: applicationId, 
            campaignId: campaignId, 
            pageSize: pageSize, 
            token: token
        )
        return try await self.getCampaignActivities(input, logger: logger)
    }

    /// Retrieves (queries) pre-aggregated data for a standard metric that applies to a campaign.
    @Sendable
    @inlinable
    public func getCampaignDateRangeKpi(_ input: GetCampaignDateRangeKpiRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCampaignDateRangeKpiResponse {
        try await self.client.execute(
            operation: "GetCampaignDateRangeKpi", 
            path: "/v1/apps/{ApplicationId}/campaigns/{CampaignId}/kpis/daterange/{KpiName}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves (queries) pre-aggregated data for a standard metric that applies to a campaign.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - campaignId: The unique identifier for the campaign.
    ///   - endTime: The last date and time to retrieve data for, as part of an inclusive date range that filters the query results. This value should be in extended ISO 8601 format and use Coordinated Universal Time (UTC), for example: 2019-07-26T20:00:00Z for 8:00 PM UTC July 26, 2019.
    ///   - kpiName: The name of the metric, also referred to as a key performance indicator (KPI), to retrieve data for. This value describes the associated metric and consists of two or more terms, which are comprised of lowercase alphanumeric characters, separated by a hyphen. Examples are email-open-rate and successful-delivery-rate. For a list of valid values, see the Amazon Pinpoint Developer Guide.
    ///   - nextToken: The  string that specifies which page of results to return in a paginated response. This parameter is not supported for application, campaign, and journey metrics.
    ///   - pageSize: The maximum number of items to include in each page of a paginated response. This parameter is not supported for application, campaign, and journey metrics.
    ///   - startTime: The first date and time to retrieve data for, as part of an inclusive date range that filters the query results. This value should be in extended ISO 8601 format and use Coordinated Universal Time (UTC), for example: 2019-07-19T20:00:00Z for 8:00 PM UTC July 19, 2019. This value should also be fewer than 90 days from the current day.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCampaignDateRangeKpi(
        applicationId: String,
        campaignId: String,
        endTime: Date? = nil,
        kpiName: String,
        nextToken: String? = nil,
        pageSize: String? = nil,
        startTime: Date? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCampaignDateRangeKpiResponse {
        let input = GetCampaignDateRangeKpiRequest(
            applicationId: applicationId, 
            campaignId: campaignId, 
            endTime: endTime, 
            kpiName: kpiName, 
            nextToken: nextToken, 
            pageSize: pageSize, 
            startTime: startTime
        )
        return try await self.getCampaignDateRangeKpi(input, logger: logger)
    }

    /// Retrieves information about the status, configuration, and other settings for a specific version of a campaign.
    @Sendable
    @inlinable
    public func getCampaignVersion(_ input: GetCampaignVersionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCampaignVersionResponse {
        try await self.client.execute(
            operation: "GetCampaignVersion", 
            path: "/v1/apps/{ApplicationId}/campaigns/{CampaignId}/versions/{Version}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the status, configuration, and other settings for a specific version of a campaign.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - campaignId: The unique identifier for the campaign.
    ///   - version: The unique version number (Version property) for the campaign version.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCampaignVersion(
        applicationId: String,
        campaignId: String,
        version: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCampaignVersionResponse {
        let input = GetCampaignVersionRequest(
            applicationId: applicationId, 
            campaignId: campaignId, 
            version: version
        )
        return try await self.getCampaignVersion(input, logger: logger)
    }

    /// Retrieves information about the status, configuration, and other settings for all versions of a campaign.
    @Sendable
    @inlinable
    public func getCampaignVersions(_ input: GetCampaignVersionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCampaignVersionsResponse {
        try await self.client.execute(
            operation: "GetCampaignVersions", 
            path: "/v1/apps/{ApplicationId}/campaigns/{CampaignId}/versions", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the status, configuration, and other settings for all versions of a campaign.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - campaignId: The unique identifier for the campaign.
    ///   - pageSize: The maximum number of items to include in each page of a paginated response. This parameter is not supported for application, campaign, and journey metrics.
    ///   - token: The NextToken string that specifies which page of results to return in a paginated response.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCampaignVersions(
        applicationId: String,
        campaignId: String,
        pageSize: String? = nil,
        token: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCampaignVersionsResponse {
        let input = GetCampaignVersionsRequest(
            applicationId: applicationId, 
            campaignId: campaignId, 
            pageSize: pageSize, 
            token: token
        )
        return try await self.getCampaignVersions(input, logger: logger)
    }

    /// Retrieves information about the status, configuration, and other settings for all the campaigns that are associated with an application.
    @Sendable
    @inlinable
    public func getCampaigns(_ input: GetCampaignsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCampaignsResponse {
        try await self.client.execute(
            operation: "GetCampaigns", 
            path: "/v1/apps/{ApplicationId}/campaigns", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the status, configuration, and other settings for all the campaigns that are associated with an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - pageSize: The maximum number of items to include in each page of a paginated response. This parameter is not supported for application, campaign, and journey metrics.
    ///   - token: The NextToken string that specifies which page of results to return in a paginated response.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCampaigns(
        applicationId: String,
        pageSize: String? = nil,
        token: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCampaignsResponse {
        let input = GetCampaignsRequest(
            applicationId: applicationId, 
            pageSize: pageSize, 
            token: token
        )
        return try await self.getCampaigns(input, logger: logger)
    }

    /// Retrieves information about the history and status of each channel for an application.
    @Sendable
    @inlinable
    public func getChannels(_ input: GetChannelsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetChannelsResponse {
        try await self.client.execute(
            operation: "GetChannels", 
            path: "/v1/apps/{ApplicationId}/channels", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the history and status of each channel for an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - logger: Logger use during operation
    @inlinable
    public func getChannels(
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetChannelsResponse {
        let input = GetChannelsRequest(
            applicationId: applicationId
        )
        return try await self.getChannels(input, logger: logger)
    }

    /// Retrieves information about the status and settings of the email channel for an application.
    @Sendable
    @inlinable
    public func getEmailChannel(_ input: GetEmailChannelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetEmailChannelResponse {
        try await self.client.execute(
            operation: "GetEmailChannel", 
            path: "/v1/apps/{ApplicationId}/channels/email", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the status and settings of the email channel for an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - logger: Logger use during operation
    @inlinable
    public func getEmailChannel(
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetEmailChannelResponse {
        let input = GetEmailChannelRequest(
            applicationId: applicationId
        )
        return try await self.getEmailChannel(input, logger: logger)
    }

    /// Retrieves the content and settings of a message template for messages that are sent through the email channel.
    @Sendable
    @inlinable
    public func getEmailTemplate(_ input: GetEmailTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetEmailTemplateResponse {
        try await self.client.execute(
            operation: "GetEmailTemplate", 
            path: "/v1/templates/{TemplateName}/email", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the content and settings of a message template for messages that are sent through the email channel.
    ///
    /// Parameters:
    ///   - templateName: The name of the message template. A template name must start with an alphanumeric character and can contain a maximum of 128 characters. The characters can be alphanumeric characters, underscores (_), or hyphens (-). Template names are case sensitive.
    ///   - version: The unique identifier for the version of the message template to update, retrieve information about, or delete. To retrieve identifiers and other information for all the versions of a template, use the Template Versions resource. If specified, this value must match the identifier for an existing template version. If specified for an update operation, this value must match the identifier for the latest existing version of the template. This restriction helps ensure that race conditions don't occur. If you don't specify a value for this parameter, Amazon Pinpoint does the following: For a get operation, retrieves information about the active version of the template. For an update operation, saves the updates to (overwrites) the latest existing version of the template, if the create-new-version parameter isn't used or is set to false. For a delete operation, deletes the template, including all versions of the template.
    ///   - logger: Logger use during operation
    @inlinable
    public func getEmailTemplate(
        templateName: String,
        version: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetEmailTemplateResponse {
        let input = GetEmailTemplateRequest(
            templateName: templateName, 
            version: version
        )
        return try await self.getEmailTemplate(input, logger: logger)
    }

    /// Retrieves information about the settings and attributes of a specific endpoint for an application.
    @Sendable
    @inlinable
    public func getEndpoint(_ input: GetEndpointRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetEndpointResponse {
        try await self.client.execute(
            operation: "GetEndpoint", 
            path: "/v1/apps/{ApplicationId}/endpoints/{EndpointId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the settings and attributes of a specific endpoint for an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - endpointId: The case insensitive unique identifier for the endpoint. The identifier can't contain $, { or }.
    ///   - logger: Logger use during operation
    @inlinable
    public func getEndpoint(
        applicationId: String,
        endpointId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetEndpointResponse {
        let input = GetEndpointRequest(
            applicationId: applicationId, 
            endpointId: endpointId
        )
        return try await self.getEndpoint(input, logger: logger)
    }

    /// Retrieves information about the event stream settings for an application.
    @Sendable
    @inlinable
    public func getEventStream(_ input: GetEventStreamRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetEventStreamResponse {
        try await self.client.execute(
            operation: "GetEventStream", 
            path: "/v1/apps/{ApplicationId}/eventstream", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the event stream settings for an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - logger: Logger use during operation
    @inlinable
    public func getEventStream(
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetEventStreamResponse {
        let input = GetEventStreamRequest(
            applicationId: applicationId
        )
        return try await self.getEventStream(input, logger: logger)
    }

    /// Retrieves information about the status and settings of a specific export job for an application.
    @Sendable
    @inlinable
    public func getExportJob(_ input: GetExportJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetExportJobResponse {
        try await self.client.execute(
            operation: "GetExportJob", 
            path: "/v1/apps/{ApplicationId}/jobs/export/{JobId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the status and settings of a specific export job for an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - jobId: The unique identifier for the job.
    ///   - logger: Logger use during operation
    @inlinable
    public func getExportJob(
        applicationId: String,
        jobId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetExportJobResponse {
        let input = GetExportJobRequest(
            applicationId: applicationId, 
            jobId: jobId
        )
        return try await self.getExportJob(input, logger: logger)
    }

    /// Retrieves information about the status and settings of all the export jobs for an application.
    @Sendable
    @inlinable
    public func getExportJobs(_ input: GetExportJobsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetExportJobsResponse {
        try await self.client.execute(
            operation: "GetExportJobs", 
            path: "/v1/apps/{ApplicationId}/jobs/export", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the status and settings of all the export jobs for an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - pageSize: The maximum number of items to include in each page of a paginated response. This parameter is not supported for application, campaign, and journey metrics.
    ///   - token: The NextToken string that specifies which page of results to return in a paginated response.
    ///   - logger: Logger use during operation
    @inlinable
    public func getExportJobs(
        applicationId: String,
        pageSize: String? = nil,
        token: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetExportJobsResponse {
        let input = GetExportJobsRequest(
            applicationId: applicationId, 
            pageSize: pageSize, 
            token: token
        )
        return try await self.getExportJobs(input, logger: logger)
    }

    /// Retrieves information about the status and settings of the GCM channel for an application.
    @Sendable
    @inlinable
    public func getGcmChannel(_ input: GetGcmChannelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetGcmChannelResponse {
        try await self.client.execute(
            operation: "GetGcmChannel", 
            path: "/v1/apps/{ApplicationId}/channels/gcm", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the status and settings of the GCM channel for an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - logger: Logger use during operation
    @inlinable
    public func getGcmChannel(
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetGcmChannelResponse {
        let input = GetGcmChannelRequest(
            applicationId: applicationId
        )
        return try await self.getGcmChannel(input, logger: logger)
    }

    /// Retrieves information about the status and settings of a specific import job for an application.
    @Sendable
    @inlinable
    public func getImportJob(_ input: GetImportJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetImportJobResponse {
        try await self.client.execute(
            operation: "GetImportJob", 
            path: "/v1/apps/{ApplicationId}/jobs/import/{JobId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the status and settings of a specific import job for an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - jobId: The unique identifier for the job.
    ///   - logger: Logger use during operation
    @inlinable
    public func getImportJob(
        applicationId: String,
        jobId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetImportJobResponse {
        let input = GetImportJobRequest(
            applicationId: applicationId, 
            jobId: jobId
        )
        return try await self.getImportJob(input, logger: logger)
    }

    /// Retrieves information about the status and settings of all the import jobs for an application.
    @Sendable
    @inlinable
    public func getImportJobs(_ input: GetImportJobsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetImportJobsResponse {
        try await self.client.execute(
            operation: "GetImportJobs", 
            path: "/v1/apps/{ApplicationId}/jobs/import", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the status and settings of all the import jobs for an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - pageSize: The maximum number of items to include in each page of a paginated response. This parameter is not supported for application, campaign, and journey metrics.
    ///   - token: The NextToken string that specifies which page of results to return in a paginated response.
    ///   - logger: Logger use during operation
    @inlinable
    public func getImportJobs(
        applicationId: String,
        pageSize: String? = nil,
        token: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetImportJobsResponse {
        let input = GetImportJobsRequest(
            applicationId: applicationId, 
            pageSize: pageSize, 
            token: token
        )
        return try await self.getImportJobs(input, logger: logger)
    }

    /// Retrieves the in-app messages targeted for the provided endpoint ID.
    @Sendable
    @inlinable
    public func getInAppMessages(_ input: GetInAppMessagesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetInAppMessagesResponse {
        try await self.client.execute(
            operation: "GetInAppMessages", 
            path: "/v1/apps/{ApplicationId}/endpoints/{EndpointId}/inappmessages", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the in-app messages targeted for the provided endpoint ID.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - endpointId: The unique identifier for the endpoint.
    ///   - logger: Logger use during operation
    @inlinable
    public func getInAppMessages(
        applicationId: String,
        endpointId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetInAppMessagesResponse {
        let input = GetInAppMessagesRequest(
            applicationId: applicationId, 
            endpointId: endpointId
        )
        return try await self.getInAppMessages(input, logger: logger)
    }

    /// Retrieves the content and settings of a message template for messages sent through the in-app channel.
    @Sendable
    @inlinable
    public func getInAppTemplate(_ input: GetInAppTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetInAppTemplateResponse {
        try await self.client.execute(
            operation: "GetInAppTemplate", 
            path: "/v1/templates/{TemplateName}/inapp", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the content and settings of a message template for messages sent through the in-app channel.
    ///
    /// Parameters:
    ///   - templateName: The name of the message template. A template name must start with an alphanumeric character and can contain a maximum of 128 characters. The characters can be alphanumeric characters, underscores (_), or hyphens (-). Template names are case sensitive.
    ///   - version: The unique identifier for the version of the message template to update, retrieve information about, or delete. To retrieve identifiers and other information for all the versions of a template, use the Template Versions resource. If specified, this value must match the identifier for an existing template version. If specified for an update operation, this value must match the identifier for the latest existing version of the template. This restriction helps ensure that race conditions don't occur. If you don't specify a value for this parameter, Amazon Pinpoint does the following: For a get operation, retrieves information about the active version of the template. For an update operation, saves the updates to (overwrites) the latest existing version of the template, if the create-new-version parameter isn't used or is set to false. For a delete operation, deletes the template, including all versions of the template.
    ///   - logger: Logger use during operation
    @inlinable
    public func getInAppTemplate(
        templateName: String,
        version: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetInAppTemplateResponse {
        let input = GetInAppTemplateRequest(
            templateName: templateName, 
            version: version
        )
        return try await self.getInAppTemplate(input, logger: logger)
    }

    /// Retrieves information about the status, configuration, and other settings for a journey.
    @Sendable
    @inlinable
    public func getJourney(_ input: GetJourneyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetJourneyResponse {
        try await self.client.execute(
            operation: "GetJourney", 
            path: "/v1/apps/{ApplicationId}/journeys/{JourneyId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the status, configuration, and other settings for a journey.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - journeyId: The unique identifier for the journey.
    ///   - logger: Logger use during operation
    @inlinable
    public func getJourney(
        applicationId: String,
        journeyId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetJourneyResponse {
        let input = GetJourneyRequest(
            applicationId: applicationId, 
            journeyId: journeyId
        )
        return try await self.getJourney(input, logger: logger)
    }

    /// Retrieves (queries) pre-aggregated data for a standard engagement metric that applies to a journey.
    @Sendable
    @inlinable
    public func getJourneyDateRangeKpi(_ input: GetJourneyDateRangeKpiRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetJourneyDateRangeKpiResponse {
        try await self.client.execute(
            operation: "GetJourneyDateRangeKpi", 
            path: "/v1/apps/{ApplicationId}/journeys/{JourneyId}/kpis/daterange/{KpiName}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves (queries) pre-aggregated data for a standard engagement metric that applies to a journey.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - endTime: The last date and time to retrieve data for, as part of an inclusive date range that filters the query results. This value should be in extended ISO 8601 format and use Coordinated Universal Time (UTC), for example: 2019-07-26T20:00:00Z for 8:00 PM UTC July 26, 2019.
    ///   - journeyId: The unique identifier for the journey.
    ///   - kpiName: The name of the metric, also referred to as a key performance indicator (KPI), to retrieve data for. This value describes the associated metric and consists of two or more terms, which are comprised of lowercase alphanumeric characters, separated by a hyphen. Examples are email-open-rate and successful-delivery-rate. For a list of valid values, see the Amazon Pinpoint Developer Guide.
    ///   - nextToken: The  string that specifies which page of results to return in a paginated response. This parameter is not supported for application, campaign, and journey metrics.
    ///   - pageSize: The maximum number of items to include in each page of a paginated response. This parameter is not supported for application, campaign, and journey metrics.
    ///   - startTime: The first date and time to retrieve data for, as part of an inclusive date range that filters the query results. This value should be in extended ISO 8601 format and use Coordinated Universal Time (UTC), for example: 2019-07-19T20:00:00Z for 8:00 PM UTC July 19, 2019. This value should also be fewer than 90 days from the current day.
    ///   - logger: Logger use during operation
    @inlinable
    public func getJourneyDateRangeKpi(
        applicationId: String,
        endTime: Date? = nil,
        journeyId: String,
        kpiName: String,
        nextToken: String? = nil,
        pageSize: String? = nil,
        startTime: Date? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetJourneyDateRangeKpiResponse {
        let input = GetJourneyDateRangeKpiRequest(
            applicationId: applicationId, 
            endTime: endTime, 
            journeyId: journeyId, 
            kpiName: kpiName, 
            nextToken: nextToken, 
            pageSize: pageSize, 
            startTime: startTime
        )
        return try await self.getJourneyDateRangeKpi(input, logger: logger)
    }

    /// Retrieves (queries) pre-aggregated data for a standard execution metric that applies to a journey activity.
    @Sendable
    @inlinable
    public func getJourneyExecutionActivityMetrics(_ input: GetJourneyExecutionActivityMetricsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetJourneyExecutionActivityMetricsResponse {
        try await self.client.execute(
            operation: "GetJourneyExecutionActivityMetrics", 
            path: "/v1/apps/{ApplicationId}/journeys/{JourneyId}/activities/{JourneyActivityId}/execution-metrics", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves (queries) pre-aggregated data for a standard execution metric that applies to a journey activity.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - journeyActivityId: The unique identifier for the journey activity.
    ///   - journeyId: The unique identifier for the journey.
    ///   - nextToken: The  string that specifies which page of results to return in a paginated response. This parameter is not supported for application, campaign, and journey metrics.
    ///   - pageSize: The maximum number of items to include in each page of a paginated response. This parameter is not supported for application, campaign, and journey metrics.
    ///   - logger: Logger use during operation
    @inlinable
    public func getJourneyExecutionActivityMetrics(
        applicationId: String,
        journeyActivityId: String,
        journeyId: String,
        nextToken: String? = nil,
        pageSize: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetJourneyExecutionActivityMetricsResponse {
        let input = GetJourneyExecutionActivityMetricsRequest(
            applicationId: applicationId, 
            journeyActivityId: journeyActivityId, 
            journeyId: journeyId, 
            nextToken: nextToken, 
            pageSize: pageSize
        )
        return try await self.getJourneyExecutionActivityMetrics(input, logger: logger)
    }

    /// Retrieves (queries) pre-aggregated data for a standard execution metric that applies to a journey.
    @Sendable
    @inlinable
    public func getJourneyExecutionMetrics(_ input: GetJourneyExecutionMetricsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetJourneyExecutionMetricsResponse {
        try await self.client.execute(
            operation: "GetJourneyExecutionMetrics", 
            path: "/v1/apps/{ApplicationId}/journeys/{JourneyId}/execution-metrics", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves (queries) pre-aggregated data for a standard execution metric that applies to a journey.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - journeyId: The unique identifier for the journey.
    ///   - nextToken: The  string that specifies which page of results to return in a paginated response. This parameter is not supported for application, campaign, and journey metrics.
    ///   - pageSize: The maximum number of items to include in each page of a paginated response. This parameter is not supported for application, campaign, and journey metrics.
    ///   - logger: Logger use during operation
    @inlinable
    public func getJourneyExecutionMetrics(
        applicationId: String,
        journeyId: String,
        nextToken: String? = nil,
        pageSize: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetJourneyExecutionMetricsResponse {
        let input = GetJourneyExecutionMetricsRequest(
            applicationId: applicationId, 
            journeyId: journeyId, 
            nextToken: nextToken, 
            pageSize: pageSize
        )
        return try await self.getJourneyExecutionMetrics(input, logger: logger)
    }

    /// Retrieves (queries) pre-aggregated data for a standard run execution metric that applies to a journey activity.
    @Sendable
    @inlinable
    public func getJourneyRunExecutionActivityMetrics(_ input: GetJourneyRunExecutionActivityMetricsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetJourneyRunExecutionActivityMetricsResponse {
        try await self.client.execute(
            operation: "GetJourneyRunExecutionActivityMetrics", 
            path: "/v1/apps/{ApplicationId}/journeys/{JourneyId}/runs/{RunId}/activities/{JourneyActivityId}/execution-metrics", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves (queries) pre-aggregated data for a standard run execution metric that applies to a journey activity.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - journeyActivityId: The unique identifier for the journey activity.
    ///   - journeyId: The unique identifier for the journey.
    ///   - nextToken: The  string that specifies which page of results to return in a paginated response. This parameter is not supported for application, campaign, and journey metrics.
    ///   - pageSize: The maximum number of items to include in each page of a paginated response. This parameter is not supported for application, campaign, and journey metrics.
    ///   - runId: The unique identifier for the journey run.
    ///   - logger: Logger use during operation
    @inlinable
    public func getJourneyRunExecutionActivityMetrics(
        applicationId: String,
        journeyActivityId: String,
        journeyId: String,
        nextToken: String? = nil,
        pageSize: String? = nil,
        runId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetJourneyRunExecutionActivityMetricsResponse {
        let input = GetJourneyRunExecutionActivityMetricsRequest(
            applicationId: applicationId, 
            journeyActivityId: journeyActivityId, 
            journeyId: journeyId, 
            nextToken: nextToken, 
            pageSize: pageSize, 
            runId: runId
        )
        return try await self.getJourneyRunExecutionActivityMetrics(input, logger: logger)
    }

    /// Retrieves (queries) pre-aggregated data for a standard run execution metric that applies to a journey.
    @Sendable
    @inlinable
    public func getJourneyRunExecutionMetrics(_ input: GetJourneyRunExecutionMetricsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetJourneyRunExecutionMetricsResponse {
        try await self.client.execute(
            operation: "GetJourneyRunExecutionMetrics", 
            path: "/v1/apps/{ApplicationId}/journeys/{JourneyId}/runs/{RunId}/execution-metrics", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves (queries) pre-aggregated data for a standard run execution metric that applies to a journey.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - journeyId: The unique identifier for the journey.
    ///   - nextToken: The  string that specifies which page of results to return in a paginated response. This parameter is not supported for application, campaign, and journey metrics.
    ///   - pageSize: The maximum number of items to include in each page of a paginated response. This parameter is not supported for application, campaign, and journey metrics.
    ///   - runId: The unique identifier for the journey run.
    ///   - logger: Logger use during operation
    @inlinable
    public func getJourneyRunExecutionMetrics(
        applicationId: String,
        journeyId: String,
        nextToken: String? = nil,
        pageSize: String? = nil,
        runId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetJourneyRunExecutionMetricsResponse {
        let input = GetJourneyRunExecutionMetricsRequest(
            applicationId: applicationId, 
            journeyId: journeyId, 
            nextToken: nextToken, 
            pageSize: pageSize, 
            runId: runId
        )
        return try await self.getJourneyRunExecutionMetrics(input, logger: logger)
    }

    /// Provides information about the runs of a journey.
    @Sendable
    @inlinable
    public func getJourneyRuns(_ input: GetJourneyRunsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetJourneyRunsResponse {
        try await self.client.execute(
            operation: "GetJourneyRuns", 
            path: "/v1/apps/{ApplicationId}/journeys/{JourneyId}/runs", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Provides information about the runs of a journey.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - journeyId: The unique identifier for the journey.
    ///   - pageSize: The maximum number of items to include in each page of a paginated response. This parameter is not supported for application, campaign, and journey metrics.
    ///   - token: The NextToken string that specifies which page of results to return in a paginated response.
    ///   - logger: Logger use during operation
    @inlinable
    public func getJourneyRuns(
        applicationId: String,
        journeyId: String,
        pageSize: String? = nil,
        token: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetJourneyRunsResponse {
        let input = GetJourneyRunsRequest(
            applicationId: applicationId, 
            journeyId: journeyId, 
            pageSize: pageSize, 
            token: token
        )
        return try await self.getJourneyRuns(input, logger: logger)
    }

    /// Retrieves the content and settings of a message template for messages that are sent through a push notification channel.
    @Sendable
    @inlinable
    public func getPushTemplate(_ input: GetPushTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetPushTemplateResponse {
        try await self.client.execute(
            operation: "GetPushTemplate", 
            path: "/v1/templates/{TemplateName}/push", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the content and settings of a message template for messages that are sent through a push notification channel.
    ///
    /// Parameters:
    ///   - templateName: The name of the message template. A template name must start with an alphanumeric character and can contain a maximum of 128 characters. The characters can be alphanumeric characters, underscores (_), or hyphens (-). Template names are case sensitive.
    ///   - version: The unique identifier for the version of the message template to update, retrieve information about, or delete. To retrieve identifiers and other information for all the versions of a template, use the Template Versions resource. If specified, this value must match the identifier for an existing template version. If specified for an update operation, this value must match the identifier for the latest existing version of the template. This restriction helps ensure that race conditions don't occur. If you don't specify a value for this parameter, Amazon Pinpoint does the following: For a get operation, retrieves information about the active version of the template. For an update operation, saves the updates to (overwrites) the latest existing version of the template, if the create-new-version parameter isn't used or is set to false. For a delete operation, deletes the template, including all versions of the template.
    ///   - logger: Logger use during operation
    @inlinable
    public func getPushTemplate(
        templateName: String,
        version: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetPushTemplateResponse {
        let input = GetPushTemplateRequest(
            templateName: templateName, 
            version: version
        )
        return try await self.getPushTemplate(input, logger: logger)
    }

    /// Retrieves information about an Amazon Pinpoint configuration for a recommender model.
    @Sendable
    @inlinable
    public func getRecommenderConfiguration(_ input: GetRecommenderConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetRecommenderConfigurationResponse {
        try await self.client.execute(
            operation: "GetRecommenderConfiguration", 
            path: "/v1/recommenders/{RecommenderId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about an Amazon Pinpoint configuration for a recommender model.
    ///
    /// Parameters:
    ///   - recommenderId: The unique identifier for the recommender model configuration. This identifier is displayed as the Recommender ID on the Amazon Pinpoint console.
    ///   - logger: Logger use during operation
    @inlinable
    public func getRecommenderConfiguration(
        recommenderId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetRecommenderConfigurationResponse {
        let input = GetRecommenderConfigurationRequest(
            recommenderId: recommenderId
        )
        return try await self.getRecommenderConfiguration(input, logger: logger)
    }

    /// Retrieves information about all the recommender model configurations that are associated with your Amazon Pinpoint account.
    @Sendable
    @inlinable
    public func getRecommenderConfigurations(_ input: GetRecommenderConfigurationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetRecommenderConfigurationsResponse {
        try await self.client.execute(
            operation: "GetRecommenderConfigurations", 
            path: "/v1/recommenders", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about all the recommender model configurations that are associated with your Amazon Pinpoint account.
    ///
    /// Parameters:
    ///   - pageSize: The maximum number of items to include in each page of a paginated response. This parameter is not supported for application, campaign, and journey metrics.
    ///   - token: The NextToken string that specifies which page of results to return in a paginated response.
    ///   - logger: Logger use during operation
    @inlinable
    public func getRecommenderConfigurations(
        pageSize: String? = nil,
        token: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetRecommenderConfigurationsResponse {
        let input = GetRecommenderConfigurationsRequest(
            pageSize: pageSize, 
            token: token
        )
        return try await self.getRecommenderConfigurations(input, logger: logger)
    }

    /// Retrieves information about the configuration, dimension, and other settings for a specific segment that's associated with an application.
    @Sendable
    @inlinable
    public func getSegment(_ input: GetSegmentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSegmentResponse {
        try await self.client.execute(
            operation: "GetSegment", 
            path: "/v1/apps/{ApplicationId}/segments/{SegmentId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the configuration, dimension, and other settings for a specific segment that's associated with an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - segmentId: The unique identifier for the segment.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSegment(
        applicationId: String,
        segmentId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSegmentResponse {
        let input = GetSegmentRequest(
            applicationId: applicationId, 
            segmentId: segmentId
        )
        return try await self.getSegment(input, logger: logger)
    }

    /// Retrieves information about the status and settings of the export jobs for a segment.
    @Sendable
    @inlinable
    public func getSegmentExportJobs(_ input: GetSegmentExportJobsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSegmentExportJobsResponse {
        try await self.client.execute(
            operation: "GetSegmentExportJobs", 
            path: "/v1/apps/{ApplicationId}/segments/{SegmentId}/jobs/export", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the status and settings of the export jobs for a segment.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - pageSize: The maximum number of items to include in each page of a paginated response. This parameter is not supported for application, campaign, and journey metrics.
    ///   - segmentId: The unique identifier for the segment.
    ///   - token: The NextToken string that specifies which page of results to return in a paginated response.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSegmentExportJobs(
        applicationId: String,
        pageSize: String? = nil,
        segmentId: String,
        token: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSegmentExportJobsResponse {
        let input = GetSegmentExportJobsRequest(
            applicationId: applicationId, 
            pageSize: pageSize, 
            segmentId: segmentId, 
            token: token
        )
        return try await self.getSegmentExportJobs(input, logger: logger)
    }

    /// Retrieves information about the status and settings of the import jobs for a segment.
    @Sendable
    @inlinable
    public func getSegmentImportJobs(_ input: GetSegmentImportJobsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSegmentImportJobsResponse {
        try await self.client.execute(
            operation: "GetSegmentImportJobs", 
            path: "/v1/apps/{ApplicationId}/segments/{SegmentId}/jobs/import", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the status and settings of the import jobs for a segment.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - pageSize: The maximum number of items to include in each page of a paginated response. This parameter is not supported for application, campaign, and journey metrics.
    ///   - segmentId: The unique identifier for the segment.
    ///   - token: The NextToken string that specifies which page of results to return in a paginated response.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSegmentImportJobs(
        applicationId: String,
        pageSize: String? = nil,
        segmentId: String,
        token: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSegmentImportJobsResponse {
        let input = GetSegmentImportJobsRequest(
            applicationId: applicationId, 
            pageSize: pageSize, 
            segmentId: segmentId, 
            token: token
        )
        return try await self.getSegmentImportJobs(input, logger: logger)
    }

    /// Retrieves information about the configuration, dimension, and other settings for a specific version of a segment that's associated with an application.
    @Sendable
    @inlinable
    public func getSegmentVersion(_ input: GetSegmentVersionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSegmentVersionResponse {
        try await self.client.execute(
            operation: "GetSegmentVersion", 
            path: "/v1/apps/{ApplicationId}/segments/{SegmentId}/versions/{Version}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the configuration, dimension, and other settings for a specific version of a segment that's associated with an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - segmentId: The unique identifier for the segment.
    ///   - version: The unique version number (Version property) for the campaign version.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSegmentVersion(
        applicationId: String,
        segmentId: String,
        version: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSegmentVersionResponse {
        let input = GetSegmentVersionRequest(
            applicationId: applicationId, 
            segmentId: segmentId, 
            version: version
        )
        return try await self.getSegmentVersion(input, logger: logger)
    }

    /// Retrieves information about the configuration, dimension, and other settings for all the versions of a specific segment that's associated with an application.
    @Sendable
    @inlinable
    public func getSegmentVersions(_ input: GetSegmentVersionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSegmentVersionsResponse {
        try await self.client.execute(
            operation: "GetSegmentVersions", 
            path: "/v1/apps/{ApplicationId}/segments/{SegmentId}/versions", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the configuration, dimension, and other settings for all the versions of a specific segment that's associated with an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - pageSize: The maximum number of items to include in each page of a paginated response. This parameter is not supported for application, campaign, and journey metrics.
    ///   - segmentId: The unique identifier for the segment.
    ///   - token: The NextToken string that specifies which page of results to return in a paginated response.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSegmentVersions(
        applicationId: String,
        pageSize: String? = nil,
        segmentId: String,
        token: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSegmentVersionsResponse {
        let input = GetSegmentVersionsRequest(
            applicationId: applicationId, 
            pageSize: pageSize, 
            segmentId: segmentId, 
            token: token
        )
        return try await self.getSegmentVersions(input, logger: logger)
    }

    /// Retrieves information about the configuration, dimension, and other settings for all the segments that are associated with an application.
    @Sendable
    @inlinable
    public func getSegments(_ input: GetSegmentsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSegmentsResponse {
        try await self.client.execute(
            operation: "GetSegments", 
            path: "/v1/apps/{ApplicationId}/segments", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the configuration, dimension, and other settings for all the segments that are associated with an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - pageSize: The maximum number of items to include in each page of a paginated response. This parameter is not supported for application, campaign, and journey metrics.
    ///   - token: The NextToken string that specifies which page of results to return in a paginated response.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSegments(
        applicationId: String,
        pageSize: String? = nil,
        token: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSegmentsResponse {
        let input = GetSegmentsRequest(
            applicationId: applicationId, 
            pageSize: pageSize, 
            token: token
        )
        return try await self.getSegments(input, logger: logger)
    }

    /// Retrieves information about the status and settings of the SMS channel for an application.
    @Sendable
    @inlinable
    public func getSmsChannel(_ input: GetSmsChannelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSmsChannelResponse {
        try await self.client.execute(
            operation: "GetSmsChannel", 
            path: "/v1/apps/{ApplicationId}/channels/sms", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the status and settings of the SMS channel for an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSmsChannel(
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSmsChannelResponse {
        let input = GetSmsChannelRequest(
            applicationId: applicationId
        )
        return try await self.getSmsChannel(input, logger: logger)
    }

    /// Retrieves the content and settings of a message template for messages that are sent through the SMS channel.
    @Sendable
    @inlinable
    public func getSmsTemplate(_ input: GetSmsTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSmsTemplateResponse {
        try await self.client.execute(
            operation: "GetSmsTemplate", 
            path: "/v1/templates/{TemplateName}/sms", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the content and settings of a message template for messages that are sent through the SMS channel.
    ///
    /// Parameters:
    ///   - templateName: The name of the message template. A template name must start with an alphanumeric character and can contain a maximum of 128 characters. The characters can be alphanumeric characters, underscores (_), or hyphens (-). Template names are case sensitive.
    ///   - version: The unique identifier for the version of the message template to update, retrieve information about, or delete. To retrieve identifiers and other information for all the versions of a template, use the Template Versions resource. If specified, this value must match the identifier for an existing template version. If specified for an update operation, this value must match the identifier for the latest existing version of the template. This restriction helps ensure that race conditions don't occur. If you don't specify a value for this parameter, Amazon Pinpoint does the following: For a get operation, retrieves information about the active version of the template. For an update operation, saves the updates to (overwrites) the latest existing version of the template, if the create-new-version parameter isn't used or is set to false. For a delete operation, deletes the template, including all versions of the template.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSmsTemplate(
        templateName: String,
        version: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSmsTemplateResponse {
        let input = GetSmsTemplateRequest(
            templateName: templateName, 
            version: version
        )
        return try await self.getSmsTemplate(input, logger: logger)
    }

    /// Retrieves information about all the endpoints that are associated with a specific user ID.
    @Sendable
    @inlinable
    public func getUserEndpoints(_ input: GetUserEndpointsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetUserEndpointsResponse {
        try await self.client.execute(
            operation: "GetUserEndpoints", 
            path: "/v1/apps/{ApplicationId}/users/{UserId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about all the endpoints that are associated with a specific user ID.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - userId: The unique identifier for the user.
    ///   - logger: Logger use during operation
    @inlinable
    public func getUserEndpoints(
        applicationId: String,
        userId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetUserEndpointsResponse {
        let input = GetUserEndpointsRequest(
            applicationId: applicationId, 
            userId: userId
        )
        return try await self.getUserEndpoints(input, logger: logger)
    }

    /// Retrieves information about the status and settings of the voice channel for an application.
    @Sendable
    @inlinable
    public func getVoiceChannel(_ input: GetVoiceChannelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetVoiceChannelResponse {
        try await self.client.execute(
            operation: "GetVoiceChannel", 
            path: "/v1/apps/{ApplicationId}/channels/voice", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the status and settings of the voice channel for an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - logger: Logger use during operation
    @inlinable
    public func getVoiceChannel(
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetVoiceChannelResponse {
        let input = GetVoiceChannelRequest(
            applicationId: applicationId
        )
        return try await self.getVoiceChannel(input, logger: logger)
    }

    /// Retrieves the content and settings of a message template for messages that are sent through the voice channel.
    @Sendable
    @inlinable
    public func getVoiceTemplate(_ input: GetVoiceTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetVoiceTemplateResponse {
        try await self.client.execute(
            operation: "GetVoiceTemplate", 
            path: "/v1/templates/{TemplateName}/voice", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the content and settings of a message template for messages that are sent through the voice channel.
    ///
    /// Parameters:
    ///   - templateName: The name of the message template. A template name must start with an alphanumeric character and can contain a maximum of 128 characters. The characters can be alphanumeric characters, underscores (_), or hyphens (-). Template names are case sensitive.
    ///   - version: The unique identifier for the version of the message template to update, retrieve information about, or delete. To retrieve identifiers and other information for all the versions of a template, use the Template Versions resource. If specified, this value must match the identifier for an existing template version. If specified for an update operation, this value must match the identifier for the latest existing version of the template. This restriction helps ensure that race conditions don't occur. If you don't specify a value for this parameter, Amazon Pinpoint does the following: For a get operation, retrieves information about the active version of the template. For an update operation, saves the updates to (overwrites) the latest existing version of the template, if the create-new-version parameter isn't used or is set to false. For a delete operation, deletes the template, including all versions of the template.
    ///   - logger: Logger use during operation
    @inlinable
    public func getVoiceTemplate(
        templateName: String,
        version: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetVoiceTemplateResponse {
        let input = GetVoiceTemplateRequest(
            templateName: templateName, 
            version: version
        )
        return try await self.getVoiceTemplate(input, logger: logger)
    }

    /// Retrieves information about the status, configuration, and other settings for all the journeys that are associated with an application.
    @Sendable
    @inlinable
    public func listJourneys(_ input: ListJourneysRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListJourneysResponse {
        try await self.client.execute(
            operation: "ListJourneys", 
            path: "/v1/apps/{ApplicationId}/journeys", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the status, configuration, and other settings for all the journeys that are associated with an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - pageSize: The maximum number of items to include in each page of a paginated response. This parameter is not supported for application, campaign, and journey metrics.
    ///   - token: The NextToken string that specifies which page of results to return in a paginated response.
    ///   - logger: Logger use during operation
    @inlinable
    public func listJourneys(
        applicationId: String,
        pageSize: String? = nil,
        token: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListJourneysResponse {
        let input = ListJourneysRequest(
            applicationId: applicationId, 
            pageSize: pageSize, 
            token: token
        )
        return try await self.listJourneys(input, logger: logger)
    }

    /// Retrieves all the tags (keys and values) that are associated with an application, campaign, message template, or segment.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/v1/tags/{ResourceArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves all the tags (keys and values) that are associated with an application, campaign, message template, or segment.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            resourceArn: resourceArn
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// Retrieves information about all the versions of a specific message template.
    @Sendable
    @inlinable
    public func listTemplateVersions(_ input: ListTemplateVersionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTemplateVersionsResponse {
        try await self.client.execute(
            operation: "ListTemplateVersions", 
            path: "/v1/templates/{TemplateName}/{TemplateType}/versions", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about all the versions of a specific message template.
    ///
    /// Parameters:
    ///   - nextToken: The  string that specifies which page of results to return in a paginated response. This parameter is not supported for application, campaign, and journey metrics.
    ///   - pageSize: The maximum number of items to include in each page of a paginated response. This parameter is not supported for application, campaign, and journey metrics.
    ///   - templateName: The name of the message template. A template name must start with an alphanumeric character and can contain a maximum of 128 characters. The characters can be alphanumeric characters, underscores (_), or hyphens (-). Template names are case sensitive.
    ///   - templateType: The type of channel that the message template is designed for. Valid values are: EMAIL, PUSH, SMS, and VOICE.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTemplateVersions(
        nextToken: String? = nil,
        pageSize: String? = nil,
        templateName: String,
        templateType: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTemplateVersionsResponse {
        let input = ListTemplateVersionsRequest(
            nextToken: nextToken, 
            pageSize: pageSize, 
            templateName: templateName, 
            templateType: templateType
        )
        return try await self.listTemplateVersions(input, logger: logger)
    }

    /// Retrieves information about all the message templates that are associated with your Amazon Pinpoint account.
    @Sendable
    @inlinable
    public func listTemplates(_ input: ListTemplatesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTemplatesResponse {
        try await self.client.execute(
            operation: "ListTemplates", 
            path: "/v1/templates", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about all the message templates that are associated with your Amazon Pinpoint account.
    ///
    /// Parameters:
    ///   - nextToken: The  string that specifies which page of results to return in a paginated response. This parameter is not supported for application, campaign, and journey metrics.
    ///   - pageSize: The maximum number of items to include in each page of a paginated response. This parameter is not supported for application, campaign, and journey metrics.
    ///   - prefix: The substring to match in the names of the message templates to include in the results. If you specify this value, Amazon Pinpoint returns only those templates whose names begin with the value that you specify.
    ///   - templateType: The type of message template to include in the results. Valid values are: EMAIL, PUSH, SMS, and VOICE. To include all types of templates in the results, don't include this parameter in your request.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTemplates(
        nextToken: String? = nil,
        pageSize: String? = nil,
        prefix: String? = nil,
        templateType: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTemplatesResponse {
        let input = ListTemplatesRequest(
            nextToken: nextToken, 
            pageSize: pageSize, 
            prefix: prefix, 
            templateType: templateType
        )
        return try await self.listTemplates(input, logger: logger)
    }

    /// Retrieves information about a phone number.
    @Sendable
    @inlinable
    public func phoneNumberValidate(_ input: PhoneNumberValidateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> PhoneNumberValidateResponse {
        try await self.client.execute(
            operation: "PhoneNumberValidate", 
            path: "/v1/phone/number/validate", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about a phone number.
    ///
    /// Parameters:
    ///   - numberValidateRequest: 
    ///   - logger: Logger use during operation
    @inlinable
    public func phoneNumberValidate(
        numberValidateRequest: NumberValidateRequest? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PhoneNumberValidateResponse {
        let input = PhoneNumberValidateRequest(
            numberValidateRequest: numberValidateRequest
        )
        return try await self.phoneNumberValidate(input, logger: logger)
    }

    /// Creates a new event stream for an application or updates the settings of an existing event stream for an application.
    @Sendable
    @inlinable
    public func putEventStream(_ input: PutEventStreamRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> PutEventStreamResponse {
        try await self.client.execute(
            operation: "PutEventStream", 
            path: "/v1/apps/{ApplicationId}/eventstream", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new event stream for an application or updates the settings of an existing event stream for an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - writeEventStream: 
    ///   - logger: Logger use during operation
    @inlinable
    public func putEventStream(
        applicationId: String,
        writeEventStream: WriteEventStream? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PutEventStreamResponse {
        let input = PutEventStreamRequest(
            applicationId: applicationId, 
            writeEventStream: writeEventStream
        )
        return try await self.putEventStream(input, logger: logger)
    }

    /// Creates a new event to record for endpoints, or creates or updates endpoint data that existing events are associated with.
    @Sendable
    @inlinable
    public func putEvents(_ input: PutEventsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> PutEventsResponse {
        try await self.client.execute(
            operation: "PutEvents", 
            path: "/v1/apps/{ApplicationId}/events", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new event to record for endpoints, or creates or updates endpoint data that existing events are associated with.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - eventsRequest: 
    ///   - logger: Logger use during operation
    @inlinable
    public func putEvents(
        applicationId: String,
        eventsRequest: EventsRequest? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PutEventsResponse {
        let input = PutEventsRequest(
            applicationId: applicationId, 
            eventsRequest: eventsRequest
        )
        return try await self.putEvents(input, logger: logger)
    }

    /// Removes one or more custom attributes, of the same attribute type, from the application. Existing endpoints still have the attributes but Amazon Pinpoint will stop capturing new or changed values for these attributes.
    @Sendable
    @inlinable
    public func removeAttributes(_ input: RemoveAttributesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RemoveAttributesResponse {
        try await self.client.execute(
            operation: "RemoveAttributes", 
            path: "/v1/apps/{ApplicationId}/attributes/{AttributeType}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes one or more custom attributes, of the same attribute type, from the application. Existing endpoints still have the attributes but Amazon Pinpoint will stop capturing new or changed values for these attributes.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - attributeType: The type of attribute or attributes to remove. Valid values are: endpoint-custom-attributes - Custom attributes that describe endpoints, such as the date when an associated user opted in or out of receiving communications from you through a specific type of channel. endpoint-metric-attributes - Custom metrics that your app reports to Amazon Pinpoint for endpoints, such as the number of app sessions or the number of items left in a cart. endpoint-user-attributes - Custom attributes that describe users, such as first name, last name, and age.
    ///   - updateAttributesRequest: 
    ///   - logger: Logger use during operation
    @inlinable
    public func removeAttributes(
        applicationId: String,
        attributeType: String,
        updateAttributesRequest: UpdateAttributesRequest? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RemoveAttributesResponse {
        let input = RemoveAttributesRequest(
            applicationId: applicationId, 
            attributeType: attributeType, 
            updateAttributesRequest: updateAttributesRequest
        )
        return try await self.removeAttributes(input, logger: logger)
    }

    /// Creates and sends a direct message.
    @Sendable
    @inlinable
    public func sendMessages(_ input: SendMessagesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SendMessagesResponse {
        try await self.client.execute(
            operation: "SendMessages", 
            path: "/v1/apps/{ApplicationId}/messages", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates and sends a direct message.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - messageRequest: 
    ///   - logger: Logger use during operation
    @inlinable
    public func sendMessages(
        applicationId: String,
        messageRequest: MessageRequest? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SendMessagesResponse {
        let input = SendMessagesRequest(
            applicationId: applicationId, 
            messageRequest: messageRequest
        )
        return try await self.sendMessages(input, logger: logger)
    }

    /// Send an OTP message
    @Sendable
    @inlinable
    public func sendOTPMessage(_ input: SendOTPMessageRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SendOTPMessageResponse {
        try await self.client.execute(
            operation: "SendOTPMessage", 
            path: "/v1/apps/{ApplicationId}/otp", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Send an OTP message
    ///
    /// Parameters:
    ///   - applicationId: The unique ID of your Amazon Pinpoint application.
    ///   - sendOTPMessageRequestParameters: 
    ///   - logger: Logger use during operation
    @inlinable
    public func sendOTPMessage(
        applicationId: String,
        sendOTPMessageRequestParameters: SendOTPMessageRequestParameters? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SendOTPMessageResponse {
        let input = SendOTPMessageRequest(
            applicationId: applicationId, 
            sendOTPMessageRequestParameters: sendOTPMessageRequestParameters
        )
        return try await self.sendOTPMessage(input, logger: logger)
    }

    /// Creates and sends a message to a list of users.
    @Sendable
    @inlinable
    public func sendUsersMessages(_ input: SendUsersMessagesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SendUsersMessagesResponse {
        try await self.client.execute(
            operation: "SendUsersMessages", 
            path: "/v1/apps/{ApplicationId}/users-messages", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates and sends a message to a list of users.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - sendUsersMessageRequest: 
    ///   - logger: Logger use during operation
    @inlinable
    public func sendUsersMessages(
        applicationId: String,
        sendUsersMessageRequest: SendUsersMessageRequest? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SendUsersMessagesResponse {
        let input = SendUsersMessagesRequest(
            applicationId: applicationId, 
            sendUsersMessageRequest: sendUsersMessageRequest
        )
        return try await self.sendUsersMessages(input, logger: logger)
    }

    /// Adds one or more tags (keys and values) to an application, campaign, message template, or segment.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/v1/tags/{ResourceArn}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Adds one or more tags (keys and values) to an application, campaign, message template, or segment.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource.
    ///   - tagsModel: 
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceArn: String,
        tagsModel: TagsModel? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = TagResourceRequest(
            resourceArn: resourceArn, 
            tagsModel: tagsModel
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Removes one or more tags (keys and values) from an application, campaign, message template, or segment.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/v1/tags/{ResourceArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes one or more tags (keys and values) from an application, campaign, message template, or segment.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource.
    ///   - tagKeys: The key of the tag to remove from the resource. To remove multiple tags, append the tagKeys parameter and argument for each additional tag to remove, separated by an ampersand (&amp;).
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceArn: String,
        tagKeys: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UntagResourceRequest(
            resourceArn: resourceArn, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    /// Enables the ADM channel for an application or updates the status and settings of the ADM channel for an application.
    @Sendable
    @inlinable
    public func updateAdmChannel(_ input: UpdateAdmChannelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateAdmChannelResponse {
        try await self.client.execute(
            operation: "UpdateAdmChannel", 
            path: "/v1/apps/{ApplicationId}/channels/adm", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Enables the ADM channel for an application or updates the status and settings of the ADM channel for an application.
    ///
    /// Parameters:
    ///   - admChannelRequest: 
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateAdmChannel(
        admChannelRequest: ADMChannelRequest? = nil,
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateAdmChannelResponse {
        let input = UpdateAdmChannelRequest(
            admChannelRequest: admChannelRequest, 
            applicationId: applicationId
        )
        return try await self.updateAdmChannel(input, logger: logger)
    }

    /// Enables the APNs channel for an application or updates the status and settings of the APNs channel for an application.
    @Sendable
    @inlinable
    public func updateApnsChannel(_ input: UpdateApnsChannelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateApnsChannelResponse {
        try await self.client.execute(
            operation: "UpdateApnsChannel", 
            path: "/v1/apps/{ApplicationId}/channels/apns", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Enables the APNs channel for an application or updates the status and settings of the APNs channel for an application.
    ///
    /// Parameters:
    ///   - apnsChannelRequest: 
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateApnsChannel(
        apnsChannelRequest: APNSChannelRequest? = nil,
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateApnsChannelResponse {
        let input = UpdateApnsChannelRequest(
            apnsChannelRequest: apnsChannelRequest, 
            applicationId: applicationId
        )
        return try await self.updateApnsChannel(input, logger: logger)
    }

    /// Enables the APNs sandbox channel for an application or updates the status and settings of the APNs sandbox channel for an application.
    @Sendable
    @inlinable
    public func updateApnsSandboxChannel(_ input: UpdateApnsSandboxChannelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateApnsSandboxChannelResponse {
        try await self.client.execute(
            operation: "UpdateApnsSandboxChannel", 
            path: "/v1/apps/{ApplicationId}/channels/apns_sandbox", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Enables the APNs sandbox channel for an application or updates the status and settings of the APNs sandbox channel for an application.
    ///
    /// Parameters:
    ///   - apnsSandboxChannelRequest: 
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateApnsSandboxChannel(
        apnsSandboxChannelRequest: APNSSandboxChannelRequest? = nil,
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateApnsSandboxChannelResponse {
        let input = UpdateApnsSandboxChannelRequest(
            apnsSandboxChannelRequest: apnsSandboxChannelRequest, 
            applicationId: applicationId
        )
        return try await self.updateApnsSandboxChannel(input, logger: logger)
    }

    /// Enables the APNs VoIP channel for an application or updates the status and settings of the APNs VoIP channel for an application.
    @Sendable
    @inlinable
    public func updateApnsVoipChannel(_ input: UpdateApnsVoipChannelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateApnsVoipChannelResponse {
        try await self.client.execute(
            operation: "UpdateApnsVoipChannel", 
            path: "/v1/apps/{ApplicationId}/channels/apns_voip", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Enables the APNs VoIP channel for an application or updates the status and settings of the APNs VoIP channel for an application.
    ///
    /// Parameters:
    ///   - apnsVoipChannelRequest: 
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateApnsVoipChannel(
        apnsVoipChannelRequest: APNSVoipChannelRequest? = nil,
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateApnsVoipChannelResponse {
        let input = UpdateApnsVoipChannelRequest(
            apnsVoipChannelRequest: apnsVoipChannelRequest, 
            applicationId: applicationId
        )
        return try await self.updateApnsVoipChannel(input, logger: logger)
    }

    /// Enables the APNs VoIP sandbox channel for an application or updates the status and settings of the APNs VoIP sandbox channel for an application.
    @Sendable
    @inlinable
    public func updateApnsVoipSandboxChannel(_ input: UpdateApnsVoipSandboxChannelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateApnsVoipSandboxChannelResponse {
        try await self.client.execute(
            operation: "UpdateApnsVoipSandboxChannel", 
            path: "/v1/apps/{ApplicationId}/channels/apns_voip_sandbox", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Enables the APNs VoIP sandbox channel for an application or updates the status and settings of the APNs VoIP sandbox channel for an application.
    ///
    /// Parameters:
    ///   - apnsVoipSandboxChannelRequest: 
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateApnsVoipSandboxChannel(
        apnsVoipSandboxChannelRequest: APNSVoipSandboxChannelRequest? = nil,
        applicationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateApnsVoipSandboxChannelResponse {
        let input = UpdateApnsVoipSandboxChannelRequest(
            apnsVoipSandboxChannelRequest: apnsVoipSandboxChannelRequest, 
            applicationId: applicationId
        )
        return try await self.updateApnsVoipSandboxChannel(input, logger: logger)
    }

    /// Updates the settings for an application.
    @Sendable
    @inlinable
    public func updateApplicationSettings(_ input: UpdateApplicationSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateApplicationSettingsResponse {
        try await self.client.execute(
            operation: "UpdateApplicationSettings", 
            path: "/v1/apps/{ApplicationId}/settings", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the settings for an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - writeApplicationSettingsRequest: 
    ///   - logger: Logger use during operation
    @inlinable
    public func updateApplicationSettings(
        applicationId: String,
        writeApplicationSettingsRequest: WriteApplicationSettingsRequest? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateApplicationSettingsResponse {
        let input = UpdateApplicationSettingsRequest(
            applicationId: applicationId, 
            writeApplicationSettingsRequest: writeApplicationSettingsRequest
        )
        return try await self.updateApplicationSettings(input, logger: logger)
    }

    /// Enables the Baidu channel for an application or updates the status and settings of the Baidu channel for an application.
    @Sendable
    @inlinable
    public func updateBaiduChannel(_ input: UpdateBaiduChannelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateBaiduChannelResponse {
        try await self.client.execute(
            operation: "UpdateBaiduChannel", 
            path: "/v1/apps/{ApplicationId}/channels/baidu", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Enables the Baidu channel for an application or updates the status and settings of the Baidu channel for an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - baiduChannelRequest: 
    ///   - logger: Logger use during operation
    @inlinable
    public func updateBaiduChannel(
        applicationId: String,
        baiduChannelRequest: BaiduChannelRequest? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateBaiduChannelResponse {
        let input = UpdateBaiduChannelRequest(
            applicationId: applicationId, 
            baiduChannelRequest: baiduChannelRequest
        )
        return try await self.updateBaiduChannel(input, logger: logger)
    }

    /// Updates the configuration and other settings for a campaign.
    @Sendable
    @inlinable
    public func updateCampaign(_ input: UpdateCampaignRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateCampaignResponse {
        try await self.client.execute(
            operation: "UpdateCampaign", 
            path: "/v1/apps/{ApplicationId}/campaigns/{CampaignId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the configuration and other settings for a campaign.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - campaignId: The unique identifier for the campaign.
    ///   - writeCampaignRequest: 
    ///   - logger: Logger use during operation
    @inlinable
    public func updateCampaign(
        applicationId: String,
        campaignId: String,
        writeCampaignRequest: WriteCampaignRequest? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateCampaignResponse {
        let input = UpdateCampaignRequest(
            applicationId: applicationId, 
            campaignId: campaignId, 
            writeCampaignRequest: writeCampaignRequest
        )
        return try await self.updateCampaign(input, logger: logger)
    }

    /// Enables the email channel for an application or updates the status and settings of the email channel for an application.
    @Sendable
    @inlinable
    public func updateEmailChannel(_ input: UpdateEmailChannelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateEmailChannelResponse {
        try await self.client.execute(
            operation: "UpdateEmailChannel", 
            path: "/v1/apps/{ApplicationId}/channels/email", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Enables the email channel for an application or updates the status and settings of the email channel for an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - emailChannelRequest: 
    ///   - logger: Logger use during operation
    @inlinable
    public func updateEmailChannel(
        applicationId: String,
        emailChannelRequest: EmailChannelRequest? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateEmailChannelResponse {
        let input = UpdateEmailChannelRequest(
            applicationId: applicationId, 
            emailChannelRequest: emailChannelRequest
        )
        return try await self.updateEmailChannel(input, logger: logger)
    }

    /// Updates an existing message template for messages that are sent through the email channel.
    @Sendable
    @inlinable
    public func updateEmailTemplate(_ input: UpdateEmailTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateEmailTemplateResponse {
        try await self.client.execute(
            operation: "UpdateEmailTemplate", 
            path: "/v1/templates/{TemplateName}/email", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an existing message template for messages that are sent through the email channel.
    ///
    /// Parameters:
    ///   - createNewVersion: Specifies whether to save the updates as a new version of the message template. Valid values are: true, save the updates as a new version; and, false, save the updates to (overwrite) the latest existing version of the template. If you don't specify a value for this parameter, Amazon Pinpoint saves the updates to (overwrites) the latest existing version of the template. If you specify a value of true for this parameter, don't specify a value for the version parameter. Otherwise, an error will occur.
    ///   - emailTemplateRequest: 
    ///   - templateName: The name of the message template. A template name must start with an alphanumeric character and can contain a maximum of 128 characters. The characters can be alphanumeric characters, underscores (_), or hyphens (-). Template names are case sensitive.
    ///   - version: The unique identifier for the version of the message template to update, retrieve information about, or delete. To retrieve identifiers and other information for all the versions of a template, use the Template Versions resource. If specified, this value must match the identifier for an existing template version. If specified for an update operation, this value must match the identifier for the latest existing version of the template. This restriction helps ensure that race conditions don't occur. If you don't specify a value for this parameter, Amazon Pinpoint does the following: For a get operation, retrieves information about the active version of the template. For an update operation, saves the updates to (overwrites) the latest existing version of the template, if the create-new-version parameter isn't used or is set to false. For a delete operation, deletes the template, including all versions of the template.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateEmailTemplate(
        createNewVersion: Bool? = nil,
        emailTemplateRequest: EmailTemplateRequest? = nil,
        templateName: String,
        version: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateEmailTemplateResponse {
        let input = UpdateEmailTemplateRequest(
            createNewVersion: createNewVersion, 
            emailTemplateRequest: emailTemplateRequest, 
            templateName: templateName, 
            version: version
        )
        return try await self.updateEmailTemplate(input, logger: logger)
    }

    /// Creates a new endpoint for an application or updates the settings and attributes of an existing endpoint for an application. You can also use this operation to define custom attributes for an endpoint. If an update includes one or more values for a custom attribute, Amazon Pinpoint replaces (overwrites) any existing values with the new values.
    @Sendable
    @inlinable
    public func updateEndpoint(_ input: UpdateEndpointRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateEndpointResponse {
        try await self.client.execute(
            operation: "UpdateEndpoint", 
            path: "/v1/apps/{ApplicationId}/endpoints/{EndpointId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new endpoint for an application or updates the settings and attributes of an existing endpoint for an application. You can also use this operation to define custom attributes for an endpoint. If an update includes one or more values for a custom attribute, Amazon Pinpoint replaces (overwrites) any existing values with the new values.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - endpointId: The case insensitive unique identifier for the endpoint. The identifier can't contain $, { or }.
    ///   - endpointRequest: 
    ///   - logger: Logger use during operation
    @inlinable
    public func updateEndpoint(
        applicationId: String,
        endpointId: String,
        endpointRequest: EndpointRequest? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateEndpointResponse {
        let input = UpdateEndpointRequest(
            applicationId: applicationId, 
            endpointId: endpointId, 
            endpointRequest: endpointRequest
        )
        return try await self.updateEndpoint(input, logger: logger)
    }

    /// Creates a new batch of endpoints for an application or updates the settings and attributes of a batch of existing endpoints for an application. You can also use this operation to define custom attributes for a batch of endpoints. If an update includes one or more values for a custom attribute, Amazon Pinpoint replaces (overwrites) any existing values with the new values.
    @Sendable
    @inlinable
    public func updateEndpointsBatch(_ input: UpdateEndpointsBatchRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateEndpointsBatchResponse {
        try await self.client.execute(
            operation: "UpdateEndpointsBatch", 
            path: "/v1/apps/{ApplicationId}/endpoints", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new batch of endpoints for an application or updates the settings and attributes of a batch of existing endpoints for an application. You can also use this operation to define custom attributes for a batch of endpoints. If an update includes one or more values for a custom attribute, Amazon Pinpoint replaces (overwrites) any existing values with the new values.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - endpointBatchRequest: 
    ///   - logger: Logger use during operation
    @inlinable
    public func updateEndpointsBatch(
        applicationId: String,
        endpointBatchRequest: EndpointBatchRequest? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateEndpointsBatchResponse {
        let input = UpdateEndpointsBatchRequest(
            applicationId: applicationId, 
            endpointBatchRequest: endpointBatchRequest
        )
        return try await self.updateEndpointsBatch(input, logger: logger)
    }

    /// Enables the GCM channel for an application or updates the status and settings of the GCM channel for an application.
    @Sendable
    @inlinable
    public func updateGcmChannel(_ input: UpdateGcmChannelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateGcmChannelResponse {
        try await self.client.execute(
            operation: "UpdateGcmChannel", 
            path: "/v1/apps/{ApplicationId}/channels/gcm", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Enables the GCM channel for an application or updates the status and settings of the GCM channel for an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - gcmChannelRequest: 
    ///   - logger: Logger use during operation
    @inlinable
    public func updateGcmChannel(
        applicationId: String,
        gcmChannelRequest: GCMChannelRequest? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateGcmChannelResponse {
        let input = UpdateGcmChannelRequest(
            applicationId: applicationId, 
            gcmChannelRequest: gcmChannelRequest
        )
        return try await self.updateGcmChannel(input, logger: logger)
    }

    /// Updates an existing message template for messages sent through the in-app message channel.
    @Sendable
    @inlinable
    public func updateInAppTemplate(_ input: UpdateInAppTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateInAppTemplateResponse {
        try await self.client.execute(
            operation: "UpdateInAppTemplate", 
            path: "/v1/templates/{TemplateName}/inapp", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an existing message template for messages sent through the in-app message channel.
    ///
    /// Parameters:
    ///   - createNewVersion: Specifies whether to save the updates as a new version of the message template. Valid values are: true, save the updates as a new version; and, false, save the updates to (overwrite) the latest existing version of the template. If you don't specify a value for this parameter, Amazon Pinpoint saves the updates to (overwrites) the latest existing version of the template. If you specify a value of true for this parameter, don't specify a value for the version parameter. Otherwise, an error will occur.
    ///   - inAppTemplateRequest: 
    ///   - templateName: The name of the message template. A template name must start with an alphanumeric character and can contain a maximum of 128 characters. The characters can be alphanumeric characters, underscores (_), or hyphens (-). Template names are case sensitive.
    ///   - version: The unique identifier for the version of the message template to update, retrieve information about, or delete. To retrieve identifiers and other information for all the versions of a template, use the Template Versions resource. If specified, this value must match the identifier for an existing template version. If specified for an update operation, this value must match the identifier for the latest existing version of the template. This restriction helps ensure that race conditions don't occur. If you don't specify a value for this parameter, Amazon Pinpoint does the following: For a get operation, retrieves information about the active version of the template. For an update operation, saves the updates to (overwrites) the latest existing version of the template, if the create-new-version parameter isn't used or is set to false. For a delete operation, deletes the template, including all versions of the template.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateInAppTemplate(
        createNewVersion: Bool? = nil,
        inAppTemplateRequest: InAppTemplateRequest? = nil,
        templateName: String,
        version: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateInAppTemplateResponse {
        let input = UpdateInAppTemplateRequest(
            createNewVersion: createNewVersion, 
            inAppTemplateRequest: inAppTemplateRequest, 
            templateName: templateName, 
            version: version
        )
        return try await self.updateInAppTemplate(input, logger: logger)
    }

    /// Updates the configuration and other settings for a journey.
    @Sendable
    @inlinable
    public func updateJourney(_ input: UpdateJourneyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateJourneyResponse {
        try await self.client.execute(
            operation: "UpdateJourney", 
            path: "/v1/apps/{ApplicationId}/journeys/{JourneyId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the configuration and other settings for a journey.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - journeyId: The unique identifier for the journey.
    ///   - writeJourneyRequest: 
    ///   - logger: Logger use during operation
    @inlinable
    public func updateJourney(
        applicationId: String,
        journeyId: String,
        writeJourneyRequest: WriteJourneyRequest? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateJourneyResponse {
        let input = UpdateJourneyRequest(
            applicationId: applicationId, 
            journeyId: journeyId, 
            writeJourneyRequest: writeJourneyRequest
        )
        return try await self.updateJourney(input, logger: logger)
    }

    /// Cancels (stops) an active journey.
    @Sendable
    @inlinable
    public func updateJourneyState(_ input: UpdateJourneyStateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateJourneyStateResponse {
        try await self.client.execute(
            operation: "UpdateJourneyState", 
            path: "/v1/apps/{ApplicationId}/journeys/{JourneyId}/state", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Cancels (stops) an active journey.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - journeyId: The unique identifier for the journey.
    ///   - journeyStateRequest: 
    ///   - logger: Logger use during operation
    @inlinable
    public func updateJourneyState(
        applicationId: String,
        journeyId: String,
        journeyStateRequest: JourneyStateRequest? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateJourneyStateResponse {
        let input = UpdateJourneyStateRequest(
            applicationId: applicationId, 
            journeyId: journeyId, 
            journeyStateRequest: journeyStateRequest
        )
        return try await self.updateJourneyState(input, logger: logger)
    }

    /// Updates an existing message template for messages that are sent through a push notification channel.
    @Sendable
    @inlinable
    public func updatePushTemplate(_ input: UpdatePushTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdatePushTemplateResponse {
        try await self.client.execute(
            operation: "UpdatePushTemplate", 
            path: "/v1/templates/{TemplateName}/push", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an existing message template for messages that are sent through a push notification channel.
    ///
    /// Parameters:
    ///   - createNewVersion: Specifies whether to save the updates as a new version of the message template. Valid values are: true, save the updates as a new version; and, false, save the updates to (overwrite) the latest existing version of the template. If you don't specify a value for this parameter, Amazon Pinpoint saves the updates to (overwrites) the latest existing version of the template. If you specify a value of true for this parameter, don't specify a value for the version parameter. Otherwise, an error will occur.
    ///   - pushNotificationTemplateRequest: 
    ///   - templateName: The name of the message template. A template name must start with an alphanumeric character and can contain a maximum of 128 characters. The characters can be alphanumeric characters, underscores (_), or hyphens (-). Template names are case sensitive.
    ///   - version: The unique identifier for the version of the message template to update, retrieve information about, or delete. To retrieve identifiers and other information for all the versions of a template, use the Template Versions resource. If specified, this value must match the identifier for an existing template version. If specified for an update operation, this value must match the identifier for the latest existing version of the template. This restriction helps ensure that race conditions don't occur. If you don't specify a value for this parameter, Amazon Pinpoint does the following: For a get operation, retrieves information about the active version of the template. For an update operation, saves the updates to (overwrites) the latest existing version of the template, if the create-new-version parameter isn't used or is set to false. For a delete operation, deletes the template, including all versions of the template.
    ///   - logger: Logger use during operation
    @inlinable
    public func updatePushTemplate(
        createNewVersion: Bool? = nil,
        pushNotificationTemplateRequest: PushNotificationTemplateRequest? = nil,
        templateName: String,
        version: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdatePushTemplateResponse {
        let input = UpdatePushTemplateRequest(
            createNewVersion: createNewVersion, 
            pushNotificationTemplateRequest: pushNotificationTemplateRequest, 
            templateName: templateName, 
            version: version
        )
        return try await self.updatePushTemplate(input, logger: logger)
    }

    /// Updates an Amazon Pinpoint configuration for a recommender model.
    @Sendable
    @inlinable
    public func updateRecommenderConfiguration(_ input: UpdateRecommenderConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateRecommenderConfigurationResponse {
        try await self.client.execute(
            operation: "UpdateRecommenderConfiguration", 
            path: "/v1/recommenders/{RecommenderId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an Amazon Pinpoint configuration for a recommender model.
    ///
    /// Parameters:
    ///   - recommenderId: The unique identifier for the recommender model configuration. This identifier is displayed as the Recommender ID on the Amazon Pinpoint console.
    ///   - updateRecommenderConfiguration: 
    ///   - logger: Logger use during operation
    @inlinable
    public func updateRecommenderConfiguration(
        recommenderId: String,
        updateRecommenderConfiguration: UpdateRecommenderConfigurationShape? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateRecommenderConfigurationResponse {
        let input = UpdateRecommenderConfigurationRequest(
            recommenderId: recommenderId, 
            updateRecommenderConfiguration: updateRecommenderConfiguration
        )
        return try await self.updateRecommenderConfiguration(input, logger: logger)
    }

    /// Creates a new segment for an application or updates the configuration, dimension, and other settings for an existing segment that's associated with an application.
    @Sendable
    @inlinable
    public func updateSegment(_ input: UpdateSegmentRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateSegmentResponse {
        try await self.client.execute(
            operation: "UpdateSegment", 
            path: "/v1/apps/{ApplicationId}/segments/{SegmentId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new segment for an application or updates the configuration, dimension, and other settings for an existing segment that's associated with an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - segmentId: The unique identifier for the segment.
    ///   - writeSegmentRequest: 
    ///   - logger: Logger use during operation
    @inlinable
    public func updateSegment(
        applicationId: String,
        segmentId: String,
        writeSegmentRequest: WriteSegmentRequest? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateSegmentResponse {
        let input = UpdateSegmentRequest(
            applicationId: applicationId, 
            segmentId: segmentId, 
            writeSegmentRequest: writeSegmentRequest
        )
        return try await self.updateSegment(input, logger: logger)
    }

    /// Enables the SMS channel for an application or updates the status and settings of the SMS channel for an application.
    @Sendable
    @inlinable
    public func updateSmsChannel(_ input: UpdateSmsChannelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateSmsChannelResponse {
        try await self.client.execute(
            operation: "UpdateSmsChannel", 
            path: "/v1/apps/{ApplicationId}/channels/sms", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Enables the SMS channel for an application or updates the status and settings of the SMS channel for an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - smsChannelRequest: 
    ///   - logger: Logger use during operation
    @inlinable
    public func updateSmsChannel(
        applicationId: String,
        smsChannelRequest: SMSChannelRequest? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateSmsChannelResponse {
        let input = UpdateSmsChannelRequest(
            applicationId: applicationId, 
            smsChannelRequest: smsChannelRequest
        )
        return try await self.updateSmsChannel(input, logger: logger)
    }

    /// Updates an existing message template for messages that are sent through the SMS channel.
    @Sendable
    @inlinable
    public func updateSmsTemplate(_ input: UpdateSmsTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateSmsTemplateResponse {
        try await self.client.execute(
            operation: "UpdateSmsTemplate", 
            path: "/v1/templates/{TemplateName}/sms", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an existing message template for messages that are sent through the SMS channel.
    ///
    /// Parameters:
    ///   - createNewVersion: Specifies whether to save the updates as a new version of the message template. Valid values are: true, save the updates as a new version; and, false, save the updates to (overwrite) the latest existing version of the template. If you don't specify a value for this parameter, Amazon Pinpoint saves the updates to (overwrites) the latest existing version of the template. If you specify a value of true for this parameter, don't specify a value for the version parameter. Otherwise, an error will occur.
    ///   - smsTemplateRequest: 
    ///   - templateName: The name of the message template. A template name must start with an alphanumeric character and can contain a maximum of 128 characters. The characters can be alphanumeric characters, underscores (_), or hyphens (-). Template names are case sensitive.
    ///   - version: The unique identifier for the version of the message template to update, retrieve information about, or delete. To retrieve identifiers and other information for all the versions of a template, use the Template Versions resource. If specified, this value must match the identifier for an existing template version. If specified for an update operation, this value must match the identifier for the latest existing version of the template. This restriction helps ensure that race conditions don't occur. If you don't specify a value for this parameter, Amazon Pinpoint does the following: For a get operation, retrieves information about the active version of the template. For an update operation, saves the updates to (overwrites) the latest existing version of the template, if the create-new-version parameter isn't used or is set to false. For a delete operation, deletes the template, including all versions of the template.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateSmsTemplate(
        createNewVersion: Bool? = nil,
        smsTemplateRequest: SMSTemplateRequest? = nil,
        templateName: String,
        version: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateSmsTemplateResponse {
        let input = UpdateSmsTemplateRequest(
            createNewVersion: createNewVersion, 
            smsTemplateRequest: smsTemplateRequest, 
            templateName: templateName, 
            version: version
        )
        return try await self.updateSmsTemplate(input, logger: logger)
    }

    /// Changes the status of a specific version of a message template to active.
    @Sendable
    @inlinable
    public func updateTemplateActiveVersion(_ input: UpdateTemplateActiveVersionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateTemplateActiveVersionResponse {
        try await self.client.execute(
            operation: "UpdateTemplateActiveVersion", 
            path: "/v1/templates/{TemplateName}/{TemplateType}/active-version", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Changes the status of a specific version of a message template to active.
    ///
    /// Parameters:
    ///   - templateActiveVersionRequest: 
    ///   - templateName: The name of the message template. A template name must start with an alphanumeric character and can contain a maximum of 128 characters. The characters can be alphanumeric characters, underscores (_), or hyphens (-). Template names are case sensitive.
    ///   - templateType: The type of channel that the message template is designed for. Valid values are: EMAIL, PUSH, SMS, and VOICE.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateTemplateActiveVersion(
        templateActiveVersionRequest: TemplateActiveVersionRequest? = nil,
        templateName: String,
        templateType: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateTemplateActiveVersionResponse {
        let input = UpdateTemplateActiveVersionRequest(
            templateActiveVersionRequest: templateActiveVersionRequest, 
            templateName: templateName, 
            templateType: templateType
        )
        return try await self.updateTemplateActiveVersion(input, logger: logger)
    }

    /// Enables the voice channel for an application or updates the status and settings of the voice channel for an application.
    @Sendable
    @inlinable
    public func updateVoiceChannel(_ input: UpdateVoiceChannelRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateVoiceChannelResponse {
        try await self.client.execute(
            operation: "UpdateVoiceChannel", 
            path: "/v1/apps/{ApplicationId}/channels/voice", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Enables the voice channel for an application or updates the status and settings of the voice channel for an application.
    ///
    /// Parameters:
    ///   - applicationId: The unique identifier for the application. This identifier is displayed as the Project ID on the Amazon Pinpoint console.
    ///   - voiceChannelRequest: 
    ///   - logger: Logger use during operation
    @inlinable
    public func updateVoiceChannel(
        applicationId: String,
        voiceChannelRequest: VoiceChannelRequest? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateVoiceChannelResponse {
        let input = UpdateVoiceChannelRequest(
            applicationId: applicationId, 
            voiceChannelRequest: voiceChannelRequest
        )
        return try await self.updateVoiceChannel(input, logger: logger)
    }

    /// Updates an existing message template for messages that are sent through the voice channel.
    @Sendable
    @inlinable
    public func updateVoiceTemplate(_ input: UpdateVoiceTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateVoiceTemplateResponse {
        try await self.client.execute(
            operation: "UpdateVoiceTemplate", 
            path: "/v1/templates/{TemplateName}/voice", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an existing message template for messages that are sent through the voice channel.
    ///
    /// Parameters:
    ///   - createNewVersion: Specifies whether to save the updates as a new version of the message template. Valid values are: true, save the updates as a new version; and, false, save the updates to (overwrite) the latest existing version of the template. If you don't specify a value for this parameter, Amazon Pinpoint saves the updates to (overwrites) the latest existing version of the template. If you specify a value of true for this parameter, don't specify a value for the version parameter. Otherwise, an error will occur.
    ///   - templateName: The name of the message template. A template name must start with an alphanumeric character and can contain a maximum of 128 characters. The characters can be alphanumeric characters, underscores (_), or hyphens (-). Template names are case sensitive.
    ///   - version: The unique identifier for the version of the message template to update, retrieve information about, or delete. To retrieve identifiers and other information for all the versions of a template, use the Template Versions resource. If specified, this value must match the identifier for an existing template version. If specified for an update operation, this value must match the identifier for the latest existing version of the template. This restriction helps ensure that race conditions don't occur. If you don't specify a value for this parameter, Amazon Pinpoint does the following: For a get operation, retrieves information about the active version of the template. For an update operation, saves the updates to (overwrites) the latest existing version of the template, if the create-new-version parameter isn't used or is set to false. For a delete operation, deletes the template, including all versions of the template.
    ///   - voiceTemplateRequest: 
    ///   - logger: Logger use during operation
    @inlinable
    public func updateVoiceTemplate(
        createNewVersion: Bool? = nil,
        templateName: String,
        version: String? = nil,
        voiceTemplateRequest: VoiceTemplateRequest? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateVoiceTemplateResponse {
        let input = UpdateVoiceTemplateRequest(
            createNewVersion: createNewVersion, 
            templateName: templateName, 
            version: version, 
            voiceTemplateRequest: voiceTemplateRequest
        )
        return try await self.updateVoiceTemplate(input, logger: logger)
    }

    /// Verify an OTP
    @Sendable
    @inlinable
    public func verifyOTPMessage(_ input: VerifyOTPMessageRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> VerifyOTPMessageResponse {
        try await self.client.execute(
            operation: "VerifyOTPMessage", 
            path: "/v1/apps/{ApplicationId}/verify-otp", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Verify an OTP
    ///
    /// Parameters:
    ///   - applicationId: The unique ID of your Amazon Pinpoint application.
    ///   - verifyOTPMessageRequestParameters: 
    ///   - logger: Logger use during operation
    @inlinable
    public func verifyOTPMessage(
        applicationId: String,
        verifyOTPMessageRequestParameters: VerifyOTPMessageRequestParameters? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> VerifyOTPMessageResponse {
        let input = VerifyOTPMessageRequest(
            applicationId: applicationId, 
            verifyOTPMessageRequestParameters: verifyOTPMessageRequestParameters
        )
        return try await self.verifyOTPMessage(input, logger: logger)
    }
}

extension Pinpoint {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: Pinpoint, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}
